web-dev-qa-db-fra.com

Comment créer un package intelligent Meteor

Comment peut-on construire un package intelligent Meteor qui apparaîtrait dans meteor list?

Construire Atmosphere packages est raisonnablement bien documenté , mais construire des packages Meteor ne l'est pas.

meteorpackage
42
Olivier Refalo

Meteor prend désormais en charge un create --package.

Voir les documents sur les météores .

Exemple (remplacez votre propre compte de développeur de météores pour "cunneen"):

meteor create --package cunneen:foo

Production:

cunneen:foo: created in your app

Résultats:

packages/cunneen: foo/package.js 

Package.describe({
  name: 'cunneen:foo',
  version: '0.0.1',
  // Brief, one-line summary of the package.
  summary: '',
  // URL to the Git repository containing the source code for this package.
  git: '',
  // By default, Meteor will default to using README.md for documentation.
  // To avoid submitting documentation, set this field to null.
  documentation: 'README.md'
});

Package.onUse(function(api) {
  api.versionsFrom('1.0.3.1');
  api.addFiles('cunneen:foo.js');
});

Package.onTest(function(api) {
  api.use('tinytest');
  api.use('cunneen:foo');
  api.addFiles('cunneen:foo-tests.js');
});

packages/cunneen: foo/foo.js (fichier vide) 

// Write your package code here!

packages/cunneen: foo/foo-tests.js 

// Write your tests here!
// Here is an example.
Tinytest.add('example', function (test) {
  test.equal(true, true);
});

packages/cunneen: foo/README.md (fichier vide) 

# cunneen:foo package

Pour un bon exemple (TRÈS complet), jetez un œil à iron-router .

21
cobberboy

Voir cobberboy's réponse ci-dessous

Ci-dessous des informations obsolètes:

Voir les informations sur le nouveau système d'emballage de météores: https://meteorhacks.com/meteor-weekly-meteor-09-rc-meteor-new-logo-underscore-in- templates.html

** informations plus anciennes **

Il y a des informations mises à jour sur écrire votre propre paquet et sur reconditionner les bibliothèques tierces existantes . L'API ne sera cependant pas stable jusqu'à 1.0, alors préparez-vous à apporter de nombreuses modifications.

J'ai inclus une plaque de chaudière pour aider à en faire à la fois un nœud et une bibliothèque utilisable de météores. Cela m'a pris un certain temps pour comprendre, ouvert aux suggestions.

package: /lib/my.js

if (typeof Meteor === 'undefined) {
    // Not Running In Meteor (nodejs code)
    // example NPM/Node Dependencies that we'll use
    var async = require('async');
    var debug = require('debug')('my:package');
    var mongodb = require('mongodb');

    var http = require('http');  
} else {
    // Running as Meteor Package
    var async = Npm.require('async');
    var debug = Npm.require('debug')('my:package');
    var mongodb = Npm.require('mongodb');

    // node core module 'http'
    // use Npm.require to require node core modules
    // but doesnt need Npm.depends in the package.js file
    var http = Npm.require('http');
}

var constructor = function(property1) {
    this.property1 = property1; // or whatever in your constructor.
};

if (typeof Meteor === 'undefined') {
   // Export it node style
   My = exports = module.exports = constructor; // Limit scope to this nodejs file
} else {
   // Export it meteor style
   My = constructor; // Make it a global
}

// Proceed defining methods / properties as usual.
My.prototype.doStuff = function() { console.log('hello world'); }

package: /package.js

Package.describe({
  summary: "My Meteor Package"
});

/**
 * Ex: Some NPM Dependencies
 */
Npm.depends({
  'async': '0.2.9',
  'debug': '0.7.2',
  'mongodb': '1.3.18'
});

/**
 * On use we'll add files and export our tool
 */
Package.on_use(function (api) {
  /**
   * Add all the files, in the order of their dependence (eg, if A.js depends on B.js, B.js must be before A.js)
   */
  api.add_files([
    'lib/my.js' // <-- include all the necessary files in the package
    ],
    'server'); // Can be 'server', 'client' , ['client','server']

  /**
   * Only expose the My constructor, only export if meteor > 0.6.5
   */
  api.export && api.export(['My'], 'server'); // 1st arg can be array of exported constructors/objects, 2nd can be 'server', 'client', ['client', 'server']
});

application météore: certains fichiers dans le contexte client/serveur approprié (tel que défini dans package.js) 

var my = new My('a property');
my.doStuff(); // console logs 'hello world' on the server

application météore: smart.json, ajoutez votre fichier à la liste des packages 

{
    packages:{
        "node-my": {
            "git": "[email protected]:myAccount/node-my.git"
        }
    }
}

Enfin exécutez mrt install sur la ligne de commande pour qu'il installe le paquet .. Ouf!

14
Mike Graf

REMARQUE: le développement de packages n'est actuellement pas documenté et l'API va changer. Tu as été prévenu!

Cela dit, il est en fait assez facile de commencer:

Tout d'abord, git clone une copie du dépôt de météores. Créez-vous un nouveau répertoire dans/packages. Placez un fichier package.js dans le répertoire (voir d'autres packages pour des exemples). Maintenant, vous avez un package!

Ensuite, exécutez le script météore à partir de votre paiement (pas celui installé par le programme d'installation). Lorsqu'il est exécuté à partir de l'extraction, le script utilise le répertoire des packages locaux dans l'extraction. Il sera même rechargé à chaud lorsque vous modifiez le code dans votre package.

Jetez un œil aux autres packages pour obtenir des exemples et vous faire une idée de ce que fait l'API.

EDIT: de nombreux progrès ont été réalisés en termes de packages tiers. Découvrez http://oortcloud.github.com/meteorite/ et https://atmosphere.meteor.com/

13
n1mmy

C'était daté du 12 juin 2013. C'était la bonne réponse à l'époque, et c'est toujours une solution alternative:

Comme l'a dit n1mmy. Ce n'est pas documenté, et vous devriez utiliser de la météorite.

Si vous insistez pour créer un package avec météore, j'ai trouvé un bon How-to non officiel, mais vous ne devriez vraiment pas le faire. Meteor proposera un moyen de créer des packages dans une prochaine version.

Ajout d'un package Meteor: https://coderwall.com/p/ork35q

La façon dont je le ferais est avec Meteorite

Évidemment, vous avez un nœud, et je suppose que vous avez un gestionnaire de paquets de nœuds (npm), donc votre meilleur moyen de créer un paquet de météores à ce jour, est de faire un paquet intelligent de météorite.

npm install meteorite

Les packages intelligents Meteorite contiennent 2 fichiers clés essentiels pour la création de packages - package.js - smart.json

Les fichiers de météorite sont stockés sous votre compte utilisateur connecté au système: ~/.meteorite /
mais sont liés à votre site actuel où vous avez créé une application météorite: project/.meteor/meteorite /

Exemple de package.js: 

Package.describe({
   summary: "User analytics suite for meteor"
});

Package.on_use(function (api) {
   api.add_files('user_analytics.js', 'client');
});

Exemple smart.json 

{
   "name": "User analytics",
   "description": "User Analytics",
   "homepage": "http://yourHomepage.com",
   "author": "Eric Leroy",
   "version": "0.1",
   "git": "https://github.com/yipyo",
   "packages" : {}
}

Si vous avez besoin de plus d'informations, vous devez installer un package mrt à partir de la liste:

mrt list

puis analysez les fichiers sous votre répertoire app/.meteor/meteorite /.

J'espère que cela vous aidera et continuez à développer la meilleure langue de l'avenir.

Voici quelques liens utiles:

6
Eric Leroy

Il y a un bon screencast sur ce sujet sur EventedMind .

6
mquandalle