javascript - define - Establecer/Desarmar un indicador de depuración durante la creación de grunt/requirejs

requirejs download

Question

Estoy empezando con requirejs y gruntjs . Tengo un indicador de depuración en la aplicación como:

var debugEnabled = true;

¿Hay alguna forma de que esto se pueda establecer en false , automáticamente desde dentro de la optimización requirejs se ejecuta desde una compilación grunt ?

EDITAR: para aclarar, solo tengo una tarea predeterminada que ejecuta el optimizador requirejs . La variable debugEnabled encuentra dentro de uno de los módulos dentro de mi aplicación, por ejemplo, AppLogger , que es una dependencia de main .

¿Hay alguna forma en que la estructura requirejs pueda establecer esta variable en false , para que la versión AppLogger de AppLogger deje de hacer console.log etc.

Answer 1

Digamos que tienes dos tareas:

• desarrollo
• producción

development hace todo lo que necesita en el desarrollo, como jshint, compilación coffeescript, ... la production requiere optimización, minificación css, ...

Luego, puede registrar una tarea de build que verifique su indicador de depuración:

    grunt.registerTask(''build'', ''run build'', function () {
        var task = debugEnabled ? ''development'' : ''production'';

        // run the targetted task
        grunt.task.run(task);
    });

En la línea de comando, grunt build lo ejecutará.

Alternativamente, puede usar el parámetro de opción en gruñido:

    grunt.registerTask(''build'', ''run build'', function () {
        // start development build by default
        var target = grunt.option(''target'') || ''development'';

        // run the targetted task
        grunt.task.run(target);
    });

En la línea de comando, grunt build --target=production lo ejecutará.

Editar:

Entendí un poco la pregunta. La única forma que veo es separar su indicador de depuración en un módulo separado:

ruta / a / debug.js

define(function() {
   return true;
});

Luego creas una versión de producción (cerca de tus tareas grupales):

ruta / a / grunt / tasks / debug.js

define(function() {
   return false;
});

Y en su tarea requirejs , usted especifica esa versión:

requirejs: {
   options: {
      paths: {
         debug: ''path/to/grunt/tasks/debug.js''
      }
   }
}

Answer 2

La respuesta de @asgoth definitivamente funcionaría, pero descubrió otras dos opciones para ''inyectar'' (o eliminar) el código durante el proceso de compilación.

Como se documenta en el archivo de ejemplo build.js , podríamos usar los pragmas de pragmas para incluir / excluir fragmentos de código durante el proceso de compilación.

//Specify build pragmas. If the source files contain comments like so:
//>>excludeStart("fooExclude", pragmas.fooExclude);
//>>excludeEnd("fooExclude");
//Then the comments that start with //>> are the build pragmas.
//excludeStart/excludeEnd and includeStart/includeEnd work, and the
//the pragmas value to the includeStart or excludeStart lines
//is evaluated to see if the code between the Start and End pragma
//lines should be included or excluded. If you have a choice to use
//"has" code or pragmas, use "has" code instead. Pragmas are harder
//to read, but they can be a bit more flexible on code removal vs.
//has-based code, which must follow JavaScript language rules.
//Pragmas also remove code in non-minified source, where has branch
//trimming is only done if the code is minified via UglifyJS or
//Closure Compiler.
pragmas: {
    fooExclude: true
},

//Same as "pragmas", but only applied once during the file save phase
//of an optimization. "pragmas" are applied both during the dependency
//mapping and file saving phases on an optimization. Some pragmas
//should not be processed during the dependency mapping phase of an
//operation, such as the pragma in the CoffeeScript loader plugin,
//which wants the CoffeeScript compiler during the dependency mapping
//phase, but once files are saved as plain JavaScript, the CoffeeScript
//compiler is no longer needed. In that case, pragmasOnSave would be used
//to exclude the compiler code during the save phase.
pragmasOnSave: {
    //Just an example
    excludeCoffeeScript: true
},

Pude ver esto en acción en el código jquery.mobile , que probablemente sea un buen lugar para aprender AMD y requirejs de.

Esto es lo que funcionó para mí:

AppLogger.js:

/* global console: false */
define(function () {

  var debugEnabled = false;
//>>excludeStart(''appBuildExclude'', pragmas.appBuildExclude);
  debugEnabled = true;
//>>excludeEnd(''appBuildExclude'');
  return {
    log:function (message) {
      if (debugEnabled && console) {
        console.log(''APP DEBUG: '' + message);
      }
    }
  };

});

Gruntfile.js:

requirejs:{
  compile:{
    options:{
      baseUrl:"js/",
      mainConfigFile:"js/main.js",
      name:''main'',
      out:''js/main.min.js'',
      pragmas:{ appBuildExclude:true }
    }
  }
}

Con esta configuración para requirejs en mi Gruntfile , la sección dentro de los pragmas de excludeStart y excludeEnd se eliminó del archivo compilado / construido.

Todavía estoy aprendiendo requirejs , por lo que no hay afirmaciones de que esta sea la mejor práctica para este tipo de cosas, pero esto seguramente funcionó para mí.