moment - twbs bootstrap meteor

Cómo construir un paquete inteligente Meteor

Question

¿Cómo se puede construir un paquete inteligente Meteor que aparezca en la meteor list ?

Construir paquetes de Atmósfera está razonablemente bien documented , pero la construcción de paquetes Meteor no lo está.

Answer 1

Esto estaba fechado el 12 de junio de 2013. Fue la respuesta correcta en ese momento, y sigue siendo una solución alternativa:

Como dijo n1mmy. No está documentado, y debes usar meteorito.

Si insiste en crear un paquete con meteoro, encontré un buen How-to no oficial, pero realmente no debería hacer esto. Meteor saldrá con una forma de crear paquetes en un próximo lanzamiento.

Creación de un paquete Meteor: https://coderwall.com/p/ork35q

La forma en que lo haría es con Meteorito

Obviamente tienes nodo, y supongo que tienes administrador de paquete de nodo (npm), así que tu mejor forma de crear un paquete de meteoritos hasta la fecha es hacer un paquete inteligente de meteoritos.

npm install meteorite

Los paquetes inteligentes Meteorite contienen 2 archivos clave esenciales para la creación del paquete - package.js - smart.json

Los archivos de Meteorito se almacenan en su cuenta de usuario registrada en el sistema: ~ / .meteorite /
pero están enlazados a tu corriente donde creaste una aplicación de meteoros: project / .meteor / meteorite /

Muestra package.js:

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

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

Muestra 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 necesita más información, debe instalar un paquete mrt de la lista:

mrt list

luego analiza los archivos en tu directorio app / .meteor / meteorite /.

Espero que esto ayude y siga desarrollando el mejor lenguaje del futuro.

Aquí hay algunos enlaces útiles:

• http://www.eventedmind.com/ - Tutoriales excepcionales que explican los conceptos básicos de Meteor
• publicación de paquetes de Atmósfera
• Preguntas frecuentes sobre meteoros no oficiales
• hacer una aplicación de sala de chat con Meteor

Answer 2

Hay un buen screencast sobre este tema en EventedMind .

Answer 3

Meteor ahora admite un comando create --package .

Ver los documentos meteorológicos .

Ejemplo (sustituya su propia cuenta de desarrollador de meteoritos por "cunneen"):

meteor create --package cunneen:foo

Salida:

cunneen:foo: created in your app

Resultados:

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 (archivo vacío)

// 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 (archivo vacío)

# cunneen:foo package

Para un buen ejemplo (MUY completo), eche un vistazo a iron-router .

Answer 4

NOTA: El desarrollo de paquetes actualmente no está documentado y la API cambiará. ¡Has sido advertido!

Dicho esto, en realidad es bastante fácil comenzar:

En primer lugar, git clone una copia del meteorito repo. Hazte un nuevo directorio en / packages. Coloque un archivo package.js en el directorio (vea otros paquetes para ver ejemplos). ¡Ahora tienes un paquete!

A continuación, ejecute el script meteorito desde su proceso de pago (no el que instaló el instalador). Cuando se ejecuta desde el proceso de pago, el script utilizará el directorio de paquetes locales en el proceso de pago. Incluso se cargará en caliente cuando cambies el código en tu paquete.

Eche un vistazo a los otros paquetes para ver ejemplos y para hacerse una idea de lo que hace la API.

EDITAR: se ha avanzado mucho en términos de paquetes de terceros. Visite http://oortcloud.github.com/meteorite/ y https://atmosphere.meteor.com/

Answer 5

Vea la respuesta de cobberboy a continuación

A continuación está la información desactualizada:

Vea información sobre el nuevo sistema de empaque de meteoros: https://meteorhacks.com/meteor-weekly-meteor-09-rc-meteor-new-logo-underscore-in-templates.html

** información anterior **

Hay información actualizada sobre cómo escribir su propio paquete y sobre cómo volver a empaquetar las bibliotecas de terceros existentes . La API no será estable hasta 1.0, así que prepárate para hacer muchos cambios.

He incluido la placa de la caldera para ayudar a convertirla en una biblioteca utilizable tanto de nodo como de meteorito a la vez. Esto me llevó bastante tiempo descubrirlo, abierto a sugerencias.

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

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

aplicación Meteor: algún archivo en el contexto adecuado cliente / servidor (como se define en package.js)

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

aplicación meteor: smart.json, agrega tu archivo a la lista de paquetes

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

Finalmente ejecute mrt install en la línea de comando para que instale el paquete ... ¡Vaya!