Comment construire un paquet intelligent Meteor

Question

Comment peut-on construire un Paquet intelligent Meteor qui apparaîtraient dans meteor list ?

Bâtiment Atmosphère les paquets sont raisonnablement bien documenté mais la construction de paquets Meteor ne l'est pas.

Answer 1

Meteor supporte maintenant un create --package commandement.

Ver les docs sur les météores .

Exemple (remplacez votre propre compte développeur meteor pour "cunneen") :

meteor create --package cunneen:foo

Sortie :

cunneen:foo: created in your app

Résultats :

paquets/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!

paquets/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 coup d'œil à routeur de fer .

Answer 2

Voir l'article de cobberboy réponse ci-dessous

Les informations ci-dessous sont périmées :

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

** information plus ancienne **

Vous trouverez des informations actualisées sur écrire votre propre paquet et sur le reconditionnement de bibliothèques tierces existantes . L'API ne sera pas stable avant la version 1.0, alors soyez prêt à faire de nombreux changements.

J'ai inclus le boiler plate pour aider à en faire à la fois un nœud et une bibliothèque utilisable par Meteor. Cela m'a pris un certain temps à comprendre, ouvert aux suggestions.

paquet : /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'); }

paquet : /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 meteor : un fichier 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 meteor : smart.json , ajouter votre fichier à la liste des paquets

{
    packages:{
        "node-my": {
            "git": "git@github.com:myAccount/node-my.git"
        }
    }
}

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

Answer 3

REMARQUE : Le développement des paquets est actuellement non documenté et l'API est appelée à évoluer. Vous êtes prévenus !

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

D'abord, clonez git une copie du repo de meteor. Créez un nouveau répertoire dans /packages. Mettez un fichier package.js dans le répertoire (voir les autres paquets pour des exemples). Maintenant vous avez un paquet !

Ensuite, exécutez le script de meteor depuis votre checkout (pas celui installé par l'installateur). Lorsqu'il est exécuté depuis le checkout, le script utilisera le répertoire local des packages dans le checkout. Il sera même rechargé à chaud lorsque vous modifiez le code dans votre paquet.

Jetez un coup d'œil aux autres paquets pour des exemples et pour avoir une idée de ce que fait l'API.

EDIT : beaucoup de progrès ont été faits en termes de paquets tiers. Consultez http://oortcloud.github.com/meteorite/ y https://atmosphere.meteor.com/

Answer 4

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

Comme n1mmy l'a dit. C'est non documenté, et vous devriez utiliser meteorite.

Si vous insistez pour créer un paquet avec meteor, j'ai trouvé un bon How-to non officiel, mais vous ne devriez vraiment pas le faire. Meteor va sortir un moyen de créer des paquets dans une prochaine version.

Compléter un paquet Meteor : https://coderwall.com/p/ork35q

La façon dont je le ferais est avec Meteorite

Il est évident que vous avez node, et je suppose que vous avez node package manager (npm), donc votre meilleur moyen de faire un paquet meteor à ce jour, est de faire un paquet meteorite smart.

npm install meteorite

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

Les fichiers Meteorite sont stockés sous votre compte utilisateur connecté au système : ~/.meteorite/
mais sont symlinkés à l'endroit où vous avez créé une application meteor : project/.meteor/meteorite/

Exemple de paquet.js :

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

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

Exemple de 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 devriez installer un paquet mrt de la liste :

mrt list

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

J'espère que cela vous aidera, et continuez à développer le meilleur langage du futur.

Voici quelques liens utiles :

• http://www.eventedmind.com/ - Des tutoriels exceptionnels expliquant les concepts fondamentaux de Meteor
• publication des forfaits Atmosphère
• FAQ non officielle sur les météores
• création d'une application de chatroom avec Meteor

Answer 5

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