Utilizzo di JSLint/Hint con requirejs

Question

Attualmente sto impostando uno script di compilazione automatico (con gruntjs) per un progetto guidato require.js. Quindi mi piacerebbe eseguire jslint/jshint su tutti i file richiesti prima di concatenarlo e ridimensionarlo con r.js. Dato che la cartella js contiene molti file di sviluppo che non voglio filtrare, non posso semplicemente passare js/**/*.js a JSLint. Il mio primo pensiero è stato quello di eseguire r.js con optimizer: 'none', filtrare il file concatenato e quindi ridimensionarlo, ma questa non è un'opzione per due motivi. In primo luogo includerà le librerie dei produttori Non voglio filtrare e in secondo luogo trovare la linea con l'errore, trovare la sua classe, trovare il file js appropriato nella cartella dev, correggerlo, eseguire r.js di nuovo e infine stenderlo di nuovo, è la via per molte seccature per il nostro flusso di lavoro. Quindi sto cercando una possibilità per collegare il linting al processo di ottimizzazione r.js o almeno ottenere un elenco dell'albero delle dipendenze requirejs in qualche modo, che posso analizzare e passarlo a lanugine. O qualsiasi soluzione praticabile per un processo automatizzato, ti verrà in mente.

Answer 1

Questa risposta sorta di bypass Grunt, ma dovrebbe funzionare per quello che si vuole fare. Il modo in cui lo farei è vedere r.js e provare a sovrascrivere una funzione che riceve il percorso dei vari moduli che vengono caricati, intercetta il nome del modulo e filtra i file mentre r.js sta caricando e compilando i moduli. L'ho fatto in questo modo:

var requirejs = require('requirejs'); 
var options = {/*r.js options as JSON*/}; 
var oldNewContext = requirejs.s.newContext; 
requirejs.s.newContext = function(){ 
    var context = oldNewContext.apply(this, arguments); 
    var oldLoad = context.Module.prototype.load; 
    context.Module.prototype.load = function(){ 
     var module = oldLoad.apply(this, arguments); 

     if(/\.js$/.test(this.map.url) && !/^empty:/.test(this.map.url)) 
      console.log(this.map.url); 

     return module; 
    } 
    return context; 
} 
requirejs.optimize(options) 

Poi, quando si esegue requirejs.optimize sui vostri moduli, si dovrebbe ottenere tutti gli URL JavaScript non vuoti registrati alla console. Invece di collegarli alla console, è possibile utilizzare gli URL per filtrare i file.

Answer 2

Prima di tutto, compilare in un secondo momento. Basta essere specifici sui file che si desidera filtrare e utilizzare il! prefisso per ignorare i file specifici:

grunt.initConfig({ 
    lint: { 
    // Specify which files to lint and which to ignore 
    all: ['js/src/*.js', '!js/src/notthisfile.js'] 
    }, 
    requirejs: { 
    compile: { 
     options: { 
     baseUrl: 'js/src', 
     name: 'project', 
     out: 'js/scripts.js' 
     } 
    } 
    } 
}); 

// Load the grunt-contrib-requirejs module. 
// Do `npm install grunt-contrib-requirejs` first 
grunt.loadNpmTasks('grunt-contrib-requirejs'); 

// Our default task (just running grunt) will 
// lint first then compile 
grunt.registerTask('default', ['lint', 'requirejs']); 

Answer 3

preferisco non sovrascrivendo i metodi di r.js, o si potrebbe creare una dipendenza indesiderata su una versione specifica (è necessario aggiornare il codice dovrebbe r.js cambiamento)

Questo è il codice che uso per lo stesso scopo, facendo uso della funzione onBuildRead di require e del fatto che gli oggetti in javascript sono passati per riferimento. Mi assicuro di eseguire prima la build richiesta, quindi rimuovere i file js.

Lo svantaggio è che ti lint dopo la compilazione completa. Per la mia configurazione non è un problema.

module.exports = function(grunt) { 



var jsHintOptions = { 
     options: { 
      curly: true, 
      eqeqeq: true, 
      eqnull: true, 
      browser: true, 
      globals: { 
       jQuery: true 
      } 
     }, 
     all: [] // <--- note this is empty! We'll fill it up as we read require dependencies 
    }; 

var requirejsOptions = { 
     compile: { 
      options: { 
       paths: { 
        "jquery": "empty:" 
       }, 
       baseUrl: "./", 
       name: "src/mypackage/main", 
       mainConfigFile: "src/mypackage/main.js", 
       out: 'build/mypackage/main.js', 
       onBuildRead: function (moduleName, path, contents) { 
        jsHintOptions.all.push(path); // <-- here we populate the jshint path array 
        return contents; 
       } 
      } 
     } 
    }; 

grunt.initConfig({ 
    pkg: grunt.file.readJSON('packages/mypackage.package.json'), 
    requirejs: requirejsOptions, 
    jshint: jsHintOptions 
}); 

// load plugin that enabled requirejs 
grunt.loadNpmTasks('grunt-contrib-requirejs'); 

// load code quality tool 
grunt.loadNpmTasks('grunt-contrib-jshint'); 


grunt.registerTask('default', ['requirejs', 'jshint']); // <-- make sure your run jshint AFTER require 
}; 

Answer 4

Invece di usare il compito lint, installare, caricare, e impostare grunt-contrib-jshint. Ha un'opzione ignores per ignorare specifici file o modelli di percorso del file.

Ecco il mio compito:

jshint: { 
    options: { 
     // options here to override JSHint defaults 
     boss : true, // Suppress warnings about assignments where comparisons are expected 
     browser : true, // Define globals exposed by modern browsers (`document`, `navigator`) 
     curly : false, // Require curly braces around blocks 
     devel : false, // Define `console`, `alert`, etc. (poor-man's debugging) 
     eqeqeq : false, // Prohibit the use of `==` and `!=` in favor of `===` and `!==` 
     "-W041" : false, // Prohibit use of `== ''` comparisons 
     eqnull : true, // Suppress warnings about `== null` comparisons 
     immed : true, // Prohibit the use of immediate function invocations w/o wrapping in parentheses 
     latedef : true, // Prohibit the use of a var before it's defined 
     laxbreak: true, // Suppress warnings about possibly unsafe line breaks 
     newcap : true, // Require you to capitalize names of constructor functions 
     noarg : true, // Prohibit the use of `arguments.caller` and `arguments.callee` 
     shadow : true, // Suppress warnings about var shadowing (declaring a var that's declared somewhere in outer scope) 
     sub  : true, // Suppress warnings about using `[]` notation, e.g. `person['name']` vs. `person.name` 
     trailing: true, // Trailing whitespace = error 
     undef : false, // Prohibit the use of explicitly undeclared variables 
     unused : false, // Warn when you define and never use your variables 
     white : false, // Check JS against Douglas Crawford's coding style 
     jquery : true, // Define globals exposed by jQuery 
     // Define global functions/libraries/etc. 
     globals : { 
      amplify : true 
     }, 
     ignores: [ 
      'src/app/templates/template.js', 
      'src/scripts/plugins/text.min.js' 
     ] 
    }, 
    gruntfile: { 
     src: 'Gruntfile.js' 
    }, 
    app: { 
     src: 'src/app/**/*.js' 
    }, 
    scripts: { 
     src: 'src/scripts/**/*.js' 
    } 
}