Gruntfile.js

module.exports = function (grunt) {
  /**
   * Load required Grunt tasks. These are installed based on the versions listed
   * in `package.json` when you do `npm install` in this directory.
   */
  grunt.loadNpmTasks('grunt-contrib-clean');
  grunt.loadNpmTasks('grunt-contrib-copy');
  grunt.loadNpmTasks('grunt-contrib-jshint');
  grunt.loadNpmTasks('grunt-contrib-concat');
  grunt.loadNpmTasks('grunt-contrib-watch');

  grunt.loadNpmTasks('grunt-contrib-coffee');
  grunt.loadNpmTasks('grunt-sass');
  grunt.loadNpmTasks('grunt-contrib-connect');
  grunt.loadNpmTasks('grunt-bump');
  grunt.loadNpmTasks('grunt-coffeelint');
  grunt.loadNpmTasks('grunt-karma');
  grunt.loadNpmTasks('grunt-ng-annotate');
  grunt.loadNpmTasks('grunt-html2js');
  grunt.loadNpmTasks('grunt-env');
  grunt.loadNpmTasks('grunt-preprocess');
  grunt.loadNpmTasks('grunt-sass-globbing');
  grunt.loadNpmTasks('grunt-postcss');
  grunt.loadNpmTasks('grunt-newer');

  var sass = require('sass');
  /**
   * Load in our build configuration file.
   */
  var userConfig = require('./build.config.js');

  /**
   * Load in our environment configuration file.
   */
  var envConfig = require('./env.config.js');

  /**
   * This is the configuration object Grunt uses to give each plugin its
   * instructions.
   */
  var taskConfig = {
    /**
     * We read in our `package.json` file so we can access the package name and
     * version. It's already there, so we don't repeat ourselves here.
     */
    pkg: grunt.file.readJSON("package.json"),

    /**
     * The banner is the comment that is placed at the top of our compiled
     * source files. It is first processed as a Grunt template, where the `<%=`
     * pairs are evaluated based on this very configuration object.
     */
    meta: {
      banner:
        '/**\n' +
        ' * <%= pkg.name %> - v<%= pkg.version %> - <%= grunt.template.today("yyyy-mm-dd") %>\n' +
        ' * <%= pkg.homepage %>\n' +
        ' *\n' +
        ' * Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author %>\n' +
        // ' * Licensed <%= pkg.licenses.type %> <<%= pkg.licenses.url %>>\n' +
        ' */\n'
    },

    /**
     * Creates a changelog on a new version.
     */
    changelog: {
      options: {
        dest: 'CHANGELOG.md',
        template: 'changelog.tpl'
      }
    },

    /**
     * Increments the version number, etc.
     */
    bump: {
      options: {
        files: [
          "package.json"
        ],
        commit: false,
        commitMessage: 'chore(release): v%VERSION%',
        commitFiles: [
          "package.json"
        ],
        createTag: false,
        tagName: 'v%VERSION%',
        tagMessage: 'Version %VERSION%',
        push: false,
        pushTo: 'origin'
      }
    },

    /**
     * The directories to delete when `grunt clean` is executed.
     */
    clean: {
      build: [
        '<%= build_dir %>/*',
        '<%= compile_dir %>/*'
      ],
      styles: [
        '<%= temp_scss_file %>'
      ]
    },

    /**
     * The `copy` task just copies files from A to B. We use it here to copy
     * our project assets (images, fonts, etc.) and javascripts into
     * `build_dir`, and then to copy the assets to `compile_dir`.
     */
    copy: {
      build_assets: {
        files: [
          {
            src: ['**'],
            dest: '<%= build_dir %>/assets/',
            cwd: 'src/assets',
            expand: true,
            follow: true
          }
        ]
      },
      font_bootstrap: {
        files: [
          {
            src: ['**'],
            dest: '<%= build_dir %>/assets/fonts/bootstrap/',
            cwd: 'node_modules/bootstrap-sass/assets/fonts/bootstrap',
            expand: true
          }
        ]
      },
      font_fontawesome: {
        files: [
          {
            src: ['**'],
            dest: '<%= build_dir %>/assets/fonts/font-awesome/',
            cwd: 'node_modules/font-awesome/fonts',
            expand: true
          }
        ]
      },
      build_app_js: {
        files: [
          {
            src: ['<%= app_files.js %>'],
            dest: '<%= build_dir %>/',
            cwd: '.',
            expand: true
          }
        ]
      },
      build_vendor_js: {
        files: [
          {
            src: ['<%= vendor_files.compile.js %>'],
            dest: '<%= build_dir %>/',
            cwd: '.',
            expand: true
          }
        ]
      },
      build_vendor_jsmap: {
        files: [
          {
            src: ['<%= vendor_files.compile.jsmap %>'],
            dest: '<%= build_dir %>',
            cwd: '.',
            expand: true
          }
        ]
      },
      copy_vendor_js: {
        files: [
          {
            src: ['<%= vendor_files.copy.js %>'],
            dest: '<%= build_dir %>/assets',
            cwd: '.',
            expand: true
          }
        ]
      },
      copy_vendor_jsmap: {
        files: [
          {
            src: ['<%= vendor_files.copy.jsmap %>'],
            dest: '<%= build_dir %>/assets',
            cwd: '.',
            expand: true
          }
        ]
      },
      copy_vendor_css: {
        files: [
          {
            src: ['<%= vendor_files.copy.css %>'],
            dest: '<%= build_dir %>/assets',
            cwd: '.',
            expand: true
          }
        ]
      },
      compile_assets: {
        files: [
          {
            src: ['**'],
            dest: '<%= compile_dir %>/assets',
            cwd: '<%= build_dir %>/assets',
            expand: true
          }
        ]
      },
      to_api: {
        files: [
          {
            src: ['**'],
            dest: '<%= api_dir %>/public',
            cwd: '<%= compile_dir %>',
            expand: true
          }
        ]
      }
    },

    /**
     * `grunt concat` concatenates multiple source files into a single file.
     */
    concat: {
      /**
       * The `compile_js` target is the concatenation of our application source
       * code and all specified vendor source code into a single file.
       */
      compile_js: {
        options: {
          banner: '<%= meta.banner %>'
        },
        src: [
          '<%= vendor_files.compile.js %>',
          'module.prefix',
          '<%= build_dir %>/src/**/*.js',
          '<%= html2js.app.dest %>',
          'module.suffix'
        ],
        dest: '<%= compile_dir %>/assets/<%= pkg.name %>.js'
      }
    },

    /**
     * `grunt coffee` compiles the CoffeeScript sources. To work well with the
     * rest of the build, we have a separate compilation task for sources and
     * specs so they can go to different places. For example, we need the
     * sources to live with the rest of the copied JavaScript so we can include
     * it in the final build, but we don't want to include our specs there.
     */
    coffee: {
      source: {
        options: {
          bare: true
        },
        expand: true,
        cwd: '.',
        src: ['<%= app_files.coffee %>'],
        dest: '<%= build_dir %>',
        ext: '.js'
      }
    },

    /**
     * Runs global imports on SASS directories. This will generate our
     * main.scss for us which will be compiled by the `sass` task
     */
    sass_globbing: {
      source: {
        files: {
          '<%= temp_scss_file %>': [
            'src/styles/vendor-config/**/*.scss',
            '<%= vendor_files.compile.scss %>',
            '<%= app_files.scss %>'
          ]
        },
        options: {
          useSingleQuotes: false
        }
      }
    },

    /**
     * Autoprefixes to handle browser vendor prefixes
     */
    postcss: {
      options: {
        map: true,
        processors: [
          require('autoprefixer')({ browsers: ['last 2 versions'] })
        ]
      },
      source: {
        src: '<%= build_dir %>/assets/<%= pkg.name %>.css',
        dest: '<%= build_dir %>/assets/<%= pkg.name %>.css'
      }
    },

    /**
     * `sass` compiles the SASS into the build path's CSS file
     */
    sass: {
      source: {
        options: {
          implementation: sass,
          lineNumbers: true,
          sourcemap: 'none'
        },
        files: [{
          cwd: '.',
          src: ['<%= temp_scss_file %>'],
          dest: '<%= build_dir %>/assets/<%= pkg.name %>.css'
        }]
      }
    },

    /**
     * `ng-annotate` annotates the sources before minifying. That is, it allows us
     * to code without the array syntax.
     */
    ngAnnotate: {
      compile: {
          files: [
              {
                expand: true,
                src: ['<%= build_dir %>/src/**/*.js',
                      '<%= app_files.js %>'],
                dest: '.',
              }
          ]
      }
  },

    /**
     * `jshint` defines the rules of our linter as well as which files we
     * should check. This file, all javascript sources, and all our unit tests
     * are linted based on the policies listed in `options`. But we can also
     * specify exclusionary patterns by prefixing them with an exclamation
     * point (!); this is useful when code comes from a third party but is
     * nonetheless inside `src/`.
     */
    jshint: {
      src: [
        '<%= app_files.js %>'
      ],
      gruntfile: [
        'Gruntfile.js'
      ],
      options: {
        curly: true,
        immed: true,
        newcap: true,
        noarg: true,
        sub: true,
        boss: true,
        eqnull: true,
        esversion: 6
      },
      // No test or globals provided - comment out to silence warnings
      // test: [
      //   '<%= app_files.jsunit %>'
      // ],
      // globals: {}
    },

    /**
     * `coffeelint` does the same as `jshint`, but for CoffeeScript.
     */
    coffeelint: {
      src: {
        files: {
          src: ['<%= app_files.coffee %>']
        }
      },
      test: {
        files: {
          src: ['<%= app_files.coffeeunit %>']
        }
      },
      options: {
        max_line_length: {
          level: 'ignore'
        }
      }
    },

    /**
     * HTML2JS is a Grunt plugin that takes all of your template files and
     * places them into JavaScript files as strings that are added to
     * AngularJS's template cache. This means that the templates too become
     * part of the initial payload as one JavaScript file. Neat!
     */
    html2js: {
      /**
       * These are the templates from `src/app`.
       */
      app: {
        options: {
          base: 'src/app'
        },
        src: ['<%= app_files.atpl %>'],
        dest: '<%= build_dir %>/templates-app.js'
      }
    },

    /**
     * The Karma configurations.
     */
    karma: {
      options: {
        configFile: '<%= build_dir %>/karma-unit.js'
      },
      unit: {
        port: 9019,
        runnerPort: 9101,
        background: true
      },
      continuous: {
        singleRun: true
      }
    },

    /**
     * The `index` task compiles the `index.html` file as a Grunt template. CSS
     * and JS files co-exist here but they get split apart later.
     */
    index: {
      /**
       * During development, we don't want to have wait for compilation,
       * concatenation, minification, etc. So to avoid these steps, we simply
       * add all script files directly to the `<head>` of `index.html`. The
       * `src` property contains the list of included files.
       */
      build: {
        dir: '<%= build_dir %>',
        src: [
          '<%= vendor_files.compile.js %>',
          '<%= build_dir %>/src/**/*.js',
          '<%= build_dir %>/assets/node_modules/**/*.css',
          '<%= build_dir %>/assets/node_modules/**/*.js',
          '<%= html2js.app.dest %>',
          '<%= postcss.source.dest %>'
        ]
      },

      /**
       * When it is time to have a completely compiled application, we can
       * alter the above to include only a single JavaScript and a single CSS
       * file. Now we're back!
       */
      compile: {
        dir: '<%= compile_dir %>',
        src: [
          '<%= compile_dir %>/assets/**/*.css',
          '<%= compile_dir %>/assets/**/*.js',
          '<%= concat.compile_js.dest %>'
        ]
      }
    },

    /**
     * This task compiles the karma template so that changes to its file array
     * don't have to be managed manually.
     */
    karmaconfig: {
      unit: {
        dir: '<%= build_dir %>',
        src: [
          '<%= vendor_files.compile.js %>',
          '<%= html2js.app.dest %>',
          'node_modules/angular-mocks/angular-mocks.js'
        ]
      }
    },

    /**
     * And for rapid development, we have a watch set up that checks to see if
     * any of the files listed below change, and then to execute the listed
     * tasks when they do. This just saves us from having to type "grunt" into
     * the command-line every time we want to see what we're working on; we can
     * instead just leave "grunt watch" running in a background terminal. Set it
     * and forget it, as Ron Popeil used to tell us.
     *
     * But we don't need the same thing to happen for all the files.
     */
    delta: {
      /**
       * Disable livereload for delta; let the BrowserSync task handle this
       * for us
       */
      options: {
        livereload: false,
        interval: 4000
      },

      /**
       * When the Gruntfile changes, we just want to lint it. In fact, when
       * your Gruntfile changes, it will automatically be reloaded! We also
       * should rebuild in case we changed any vendor files
       */
      gruntfile: {
        files: 'Gruntfile.js',
        tasks: ['jshint:gruntfile', 'build']
      },

      /**
       * When our JavaScript source files change, we want to run lint them and
       * run our unit tests.
       */
      jssrc: {
        files: [
          '<%= app_files.js %>'
        ],
        tasks: ['jshint:src', 'copy:build_app_js']
      },

      /**
       * When our CoffeeScript source files change, we want to run lint them and
       * run our unit tests.
       */
      coffeesrc: {
        files: [
          '<%= app_files.coffee %>'
        ],
        tasks: ['newer:coffeelint:src', 'newer:coffee:source', 'copy:build_app_js'] //'karma:unit:run',
      },

      /**
       * When assets are changed, copy them. Note that this will *not* copy new
       * files, so this is probably not very useful.
       */
      assets: {
        files: [
          'src/assets/**/*'
        ],
        tasks: ['copy:build_assets']
      },

      /**
       * When index.html changes, we need to compile it.
       */
      html: {
        files: ['<%= app_files.html %>'],
        tasks: ['newer:index:build']
      },

      /**
       * When our templates change, we only rewrite the template cache.
       */
      tpls: {
        files: [
          '<%= app_files.atpl %>',
        ],
        tasks: ['newer:html2js']
      },

      /**
       * When the CSS files change, we need to compile and minify them.
       */
      styles: {
        files: ['src/**/*.scss'],
        tasks: ['styles']
      },

      /**
       * When a JavaScript unit test file changes, we only want to lint it and
       * run the unit tests. We don't want to do any live reloading.
       */
      jsunit: {
        files: [
          '<%= app_files.jsunit %>'
        ],
        tasks: ['jshint:test', 'karma:unit:run']
      },

      /**
       * When a CoffeeScript unit test file changes, we only want to lint it and
       * run the unit tests. We don't want to do any live reloading.
       */
      coffeeunit: {
        files: [
          '<%= app_files.coffeeunit %>'
        ],
        tasks: ['coffeelint:test', 'karma:unit:run']
      }
    }, // end delta

    /**
     * Use the browserSync task to reload our web browser on change
     */
    // browserSync: {
    //   dev: {
    //     bsFiles: {
    //       // Watch build directory
    //       src: userConfig.build_dir + '/**/*.*'
    //     },
    //     options: {
    //       watchTask: true,
    //       server: '<%= build_dir %>',
    //       port: 8000
    //     }
    //   }
    // }
  }; // end task config

  grunt.initConfig(grunt.util._.extend(taskConfig, userConfig, envConfig));

  /**
   * Allow override for development env using NODE_ENV
   */
  gruntEnv = "env:" + (process.env.NODE_ENV || 'development');

  /**
   * In order to make it safe to just compile or copy *only* what was changed,
   * we need to ensure we are starting from a clean, fresh build. So we rename
   * the `watch` task to `delta` (that's why the configuration var above is
   * `delta`) and then add a new task called `watch` that does a clean build
   * before watching for changes.
   */
  grunt.renameTask('watch', 'delta');
  grunt.registerTask('watch', ['build', 'delta']);

  /**
   * Grunt watchsvr no longer exists
   */
  grunt.registerTask('watchsvr', function () {
    grunt.log.warn('`grunt watchsvr` has been deprecated. Just use `grunt` instead');
  });

  /**
   * The default task is to build and compile.
   */
  grunt.registerTask('deploy', ['production', 'copy:to_api']);
  grunt.registerTask('production', ['env:production', 'build', 'compile']);
  grunt.registerTask('development', ['watch']);
  grunt.registerTask('default', ['development']);

  /**
   * Style tasks in one grunt task
   */
  grunt.registerTask('styles', [
    'sass_globbing',
    'sass',
    'postcss',
    'clean:styles'
  ]);

  /**
   * The `build` task gets your app ready to run for development and testing.
   */
  grunt.registerTask('build', [
    gruntEnv,
    'clean',
    'html2js',
    'jshint',
    'coffeelint',
    'coffee',
    'styles',
    'ngAnnotate',
    'copy:build_assets',
    'copy:font_bootstrap',
    'copy:font_fontawesome',
    'copy:build_app_js',
    'copy:build_vendor_js',
    'copy:build_vendor_jsmap',
    'copy:copy_vendor_js',
    'copy:copy_vendor_jsmap',
    'copy:copy_vendor_css',
    'index:build',
    'preprocess'
  ]);

  /**
   * The `compile` task gets your app ready for deployment by concatenating and
   * minifying your code.
   */
  grunt.registerTask('compile', [
    'styles',
    'copy:compile_assets',
    'ngAnnotate',
    'concat',
    'index:compile'
  ]);

  /**
   * A utility function to get all app JavaScript sources.
   */
  function filterForJS(files) {
    return files.filter(function (file) {
      return file.match(/\.js$/);
    });
  }

  /**
   * A utility function to get all app CSS sources.
   */
  function filterForCSS(files) {
    return files.filter(function (file) {
      return file.match(/\.css$/);
    });
  }

  /**
   * The index.html template includes the stylesheet and javascript sources
   * based on dynamic names calculated in this Gruntfile. This task assembles
   * the list into variables for the template to use and then runs the
   * compilation.
   */
  grunt.registerMultiTask('index', 'Process index.html template', function () {
    var dirRE = new RegExp('^(' + grunt.config('build_dir') + '|' + grunt.config('compile_dir') + ')\/', 'g');
    var jsFiles = filterForJS(this.filesSrc).map(function (file) {
      return file.replace(dirRE, '');
    });
    var cssFiles = filterForCSS(this.filesSrc).map(function (file) {
      return file.replace(dirRE, '');
    });

    grunt.file.copy('src/index.html', this.data.dir + '/index.html', {
      process: function (contents, path) {
        return grunt.template.process(contents, {
          data: {
            scripts: jsFiles,
            styles: cssFiles,
            version: grunt.config('pkg.version')
          }
        });
      }
    });
  });

  /**
   * In order to avoid having to specify manually the files needed for karma to
   * run, we use grunt to manage the list for us. The `karma/*` files are
   * compiled as grunt templates for use by Karma. Yay!
   */
  grunt.registerMultiTask('karmaconfig', 'Process karma config templates', function () {
    var jsFiles = filterForJS(this.filesSrc);

    grunt.file.copy('karma/karma-unit.tpl.js', grunt.config('build_dir') + '/karma-unit.js', {
      process: function (contents, path) {
        return grunt.template.process(contents, {
          data: {
            scripts: jsFiles
          }
        });
      }
    });
  });

};