prova Grunt per UMD

Question

Sto cercando di capire l'approccio migliore per testare una definizione del modulo JavaScript utilizzando una fabbrica di UMD, simile a questo: https://github.com/umdjs/umd/blob/master/returnExportsGlobal.js

Non voglio testare il modulo stesso, voglio per verificare che il modulo sia 'esportato/creato' correttamente nei vari ambienti:

1. Se CommonJS (nodo), il modulo viene esportato correttamente?
2. Se AMD, è definito correttamente?
3. Se il browser (senza requirejs), è il globale corretto creato?

Vorrei eseguire questi test utilizzando grunt e gelsomino. Posso usare grunt-contrib-jasmine per testare i punti 2 e 3, ma non per il punto 1.

Suppongo di poter utilizzare una miscela di grunt-contrib-jasmine e grunt-jasmine-node per testare il modulo corretto definizioni (implementazione specifica che avrei ancora bisogno di capire), ma sembra molto disordinato.

A un livello elevato, qualcuno sa di metodi esistenti per ottenere questo risultato senza utilizzare più plugin per grunt?

Answer 1

Alla fine, ho deciso di andare con le attività ibride, utilizzando grunt-contrib-jasmine per i test globali di browser e browser AMD e jasmine_node per i test di CommonJS. Ho solo una specifica file che supporta tutti e 3 i test di tipo di modulo.

Ecco il mio grugnito config:

grunt.initConfig({ 
    pkg: grunt.file.readJSON('package.json'), 
    jasmine: { 
    browserGlobal: { 
     src: ['src/Foo.js'], 
     options: { 
     specs: 'spec/**/*.spec.js' 
     } 
    }, 
    browserAMD: { 
     src: ['src/Foo.js'], 
     options: { 
     specs: 'spec/**/*.spec.js', 
     template: require('grunt-template-jasmine-requirejs') 
     } 
    } 
    }, 
    jasmine_node: { 
    specNameMatcher: 'spec', 
    projectRoot: 'spec/' 
    } 
}); 

miei file spec gelsomino ora supportano UMD:

(function (root, factory) { 
    if (typeof module === 'object' && module.exports) { 
    // Node/CommonJS 
    factory(
     require('modulename') 
    ); 
    } else if (typeof define === 'function' && define.amd) { 
    // AMD 
    define([ 
     'modulename' 
    ], factory); 
    } else { 
    // Browser globals 
    factory(root.ModuleName); 
    } 
}(this, function factory(ModuleName) { 

// Tests here 
})); 

Ed ecco la fabbrica UMD sto usando per il mio modulo:

(function (root, factory) { 
    if (typeof module === 'object' && module.exports) { 
    // Node/CommonJS 
    module.exports = factory(); 
    } else if (typeof define === 'function' && define.amd) { 
    // AMD. Register as an anonymous module. 
    define(factory); 
    } else { 
    // Browser globals 
    root.ModuleName = factory(); 
    } 
}(this, function factory() { 


    // public API 
    return { 
    foo: 'bar' 
    }; 
})); 

Answer 2

È inoltre possibile utilizzare uRequire e salvare se stessi da tutti gli standard di UMD in tutti i moduli, mentre si utilizza declarative features.

È sufficiente scrivere pianura moduli semplici CommonJS (o un mix di due) e convertire in UMD (o un rjs ottimizzato combined.js che viene eseguito come-è in nodejs, Web/AMD & Web/Script AMD o) con un semplice build step and config, in CLI o grunt.

L'UMD prodotto si basa su modelli ben noti come https://github.com/umdjs/umd/blob/master/returnExportsGlobal.js, con varie modifiche, uno dei quali è possibile declaratively export to window/global.

È quindi possibile convertire semplici specifiche AMD o commonJS in UMD e/o "combined.js" e premere entrambi in un browser o grunt-mocha. Vedi uBerscore per molti esempi banali e più avanzati.