Working on Elixir rewrite

Author: Jeffrey Way

.gitignore

@@ -1,3 +1,4 @@
 .idea/
 node_modules/
-npm-debug.log
+npm-debug.log
+todo.txt

Config.js

@@ -1,89 +1,141 @@
-var util = require('gulp-util');
-var fs = require('fs');
-var _ = require('underscore');
+var p = require('path');
+var gutils = require('gulp-util');
+
+/*
+ |----------------------------------------------------------------
+ | Master Configuration
+ |----------------------------------------------------------------
+ |
+ | This file contains the proper paths and options for each and
+ | and every Gulp task that Elixir wraps up. To override any
+ | setting, reference elixir.config.* from your Gulpfile.
+ |
+ | Alternatively you may create an elixir.json file within your
+ | project root. As JSON, modify any settings contained here
+ | and they'll take precedence over these defaults. Easy!
+ |
+ */
 
 var config = {
-    production:   !! util.env.production,
-    srcDir:       'app',
-    publicDir:    'public',
-    assetsDir:    'resources/assets/',
-    cssOutput:    'public/css',
-    jsOutput:     'public/js',
-    sourcemaps:   ! util.env.production,
-    autoprefix:   true,
-    tasks:        [],
-    collections:  [],
-    watchers:     { default: {} },
-    babelOptions: {
-        stage: 2,
-        compact: false
+
+    tasks: [],
+
+    assetsPath: 'resources/assets',
+
+    publicPath: 'public',
+
+    appPath: 'app',
+
+    production: !! gutils.env.production,
+
+    sourcemaps: true,
+
+    css: {
+        folder: 'css',
+
+        outputFolder: 'css',
+
+        autoprefix: {
+            enabled: true,
+
+            options:  {
+                browsers: ['last 2 versions'],
+                cascade: false
+            }
+        },
+
+        sass: {
+            folder: 'sass',
+
+            pluginOptions: {
+                outputStyle: !! gutils.env.production
+                    ? 'compressed'
+                    : 'nested'
+            }
+        },
+
+        less: {
+            folder: 'less',
+
+            pluginOptions: {}
+        }
     },
-    autoprefixerOptions: {
-        browsers: ['last 2 versions'],
-        cascade: false
-    }
-};
 
+    js: {
+        folder: 'js',
 
-/**
- * Designate that the given task should be watched.
- *
- * @param {string} task
- * @param {string} search
- * @param {string} group
- */
-config.registerWatcher = function(task, search, group) {
-    group = group || 'default';
+        outputFolder: 'js',
 
-    this.watchers[group] = this.watchers[group] || {};
+        babel: {
+            options: {
+                stage: 2,
+                compact: false
+            }
+        },
 
-    this.watchers[group][task] = search;
+        browserify: {
+            options: {}
+        },
 
-    return this;
-};
+        coffee: {
+            folder: 'coffee',
 
+            options: {}
+        }
+    },
 
-/**
- * Register the given task to be triggered by Gulp.
- *
- * @param {string} task
- */
-config.queueTask = function(task) {
-    if (! _.contains(this.tasks, task)) {
-        this.tasks.push(task);
+    testing: {
+        phpUnit: {
+            path: 'tests',
+
+            options: {
+                debug: true,
+                notify: true
+            }
+        },
+
+        phpSpec: {
+            path: 'spec',
+
+            options: {
+                verbose: 'v',
+                notify: true
+            }
+        }
+    },
+
+    versioning: {
+        buildFolder: 'build'
     }
 
-    return this;
 };
 
 
 /**
- * Set the default directory paths.
+ * Fetch a config item, using a string dot-notation.
  *
- * @param {string} file
+ * @param  {string} path
+ * @return {mixed}
  */
-config.setDefaultsFrom = function(file) {
-    var defaults;
+config.get = function(path) {
+    var basePath;
+    var current = config;
 
-    if (fs.existsSync(file)) {
-        defaults = JSON.parse(fs.readFileSync(file, 'utf8'));
+    var segments = path.split('.');
 
-        _.extend(this, defaults);
+    // If the path begins with "assets" or "public," then
+    // we can assume that the user wants to prefix the
+    // a base path to the given option they request.
+    if (segments[0] == 'assets' || segments[0] == 'public') {
+        basePath = config[segments.shift()+'Path'];
     }
-};
 
+    segments.forEach(function(segment) {
+        current = current[segment];
+    });
 
-/**
- * Store a set of data in a collection.
- *
- * @param {string} key
- * @param {object} data
- */
-config.saveTask = function(key, data) {
-    this.collections[key] = this.collections[key] || [];
-
-    this.collections[key].push(data);
-}
+    return p.join(basePath, current);
+};
 
 
 module.exports = config;

GulpPaths.js

@@ -0,0 +1,123 @@
+var p = require('path');
+var gutils = require('gulp-util');
+var parsePath = require('parse-filepath');
+
+
+/**
+ * Create a new GulpPaths constructor.
+ *
+ * @param {string|array} path
+ * @param {string}       defaultName
+ */
+var GulpPaths = function() {};
+
+
+/**
+ * Set the Gulp src file(s) and path prefix.
+ *
+ * @param {string|array} src
+ * @param {string}       prefix
+ */
+GulpPaths.prototype.src = function(src, prefix) {
+    src = this.prefix(src, prefix);
+
+    if (Array.isArray(src)) {
+        this.src = { path: src, baseDir: prefix };
+    } else {
+        this.src = this.parse(src);
+
+        // If a directory is provided as the Gulp src,
+        // the user probably wants everything in it.
+        this.src.isDir && (this.src.path += '/**/*');
+    }
+
+    return this;
+}
+
+
+/**
+ * Set the Gulp output path.
+ *
+ * @param {string} src
+ * @param {string} prefix
+ */
+GulpPaths.prototype.output = function(output, defaultName) {
+    this.output = this.parse(output);
+
+    // If the user didn't provide a path AND file name
+    // then we'll do our best to choose a default.
+    if ( ! this.output.name && defaultName) {
+        // We'll check to see if the provided src is not
+        // an array. If so, we'll use that single file
+        // name as the output name. But we must also
+        // change the extension (.sass -> .css).
+        if ( ! Array.isArray(this.src.path) && this.src.name.indexOf('*') == -1) {
+            defaultName = this.changeExtension(
+                this.src.name,
+                this.parse(defaultName).extension
+            );
+        }
+
+        this.output = this.parse(p.join(output, defaultName));
+    }
+
+    return this;
+}
+
+
+/**
+ * Change the file extension for a path.
+ *
+ * @param {string} path
+ * @param {string} newExtension
+ */
+GulpPaths.prototype.changeExtension = function(path, newExtension) {
+    return gutils.replaceExtension(path, newExtension);
+};
+
+
+/**
+ * Apply a path prefix to the path(s).
+ *
+ * @param  {string} prefix
+ * @return {string|array}
+ */
+GulpPaths.prototype.prefix = function(path, prefix) {
+    if ( ! prefix) return path;
+
+    var prefixOne = function(path) {
+        return p.join(prefix, path)
+            .replace(/\/\//g, '/')
+            .replace(p.join(prefix, prefix), prefix);
+    };
+
+    if (Array.isArray(path)) {
+        return path.map(prefixOne);
+    }
+
+    return prefixOne(path);
+};
+
+
+/**
+ * Parse the given file path.
+ *
+ * @param  {string} path
+ * @return {object}
+ */
+GulpPaths.prototype.parse = function(path) {
+    var segments = parsePath(path);
+
+    return {
+        path      : path,
+        name      : segments.extname ? segments.basename : '',
+        extension : segments.extname,
+        isDir     : ! (!! segments.extname),
+        baseDir   : segments.extname
+                        ? segments.dirname
+                        : p.join(segments.dirname, segments.basename)
+    };
+};
+
+
+module.exports = GulpPaths;