Adding a basic lint for tabs vs spaces for C# and C++, will eventually be hooked up to CI

Build/Scripts/Bootstrap.js

@@ -1,15 +1,17 @@
 
+// Load `jake` global
+require('../node_modules/jake/lib/jake');
+
+// Load jake tasks, patch in our node modules, etc
+var host = require('./Host');
+
 var os = require('os');
 
 // Parse args
-var options = require('./Minimist')(process.argv.slice(2));
+var options = require('minimist')(process.argv.slice(2));
 var cmd = options._[0];
 
-// Load `jake` global
-require('../node_modules/jake/lib/jake');
 
-// Load jake tasks, etc
-var host = require('./Host');
 
 // Make options availabe to host
 host.options = options;
@@ -33,6 +35,11 @@ if (options["help"]) {
     printHelp();
 }
 
+if (options["lint"]) {
+    var lintTask = jake.Task['build:lint'];
+    lintTask.invoke();
+}
+
 // Atomic Editor Build
 if (cmd == "buildeditor") {
 

Build/Scripts/BuildLint.js

@@ -0,0 +1,85 @@
+var fs = require('fs-extra');
+var path = require("path");
+var host = require("./Host");
+var os = require('os');
+var glob = require("glob");
+
+var fixTabs = false;
+
+var atomicRoot = host.atomicRoot;
+
+// Oh, JavaScript
+atomicRoot = atomicRoot.split("\\");
+atomicRoot = atomicRoot.join("/");
+
+function lintFile(filename) {
+
+    var file = fs.readFileSync(filename, "utf-8");
+
+    if (file.indexOf('\t') != -1) {
+
+        console.log(filename + "  contains tab character");
+
+        if (fixTabs) {
+            
+            var fd = fs.openSync(filename, "w");
+
+            var tabbed = file.split('\t');
+            file = tabbed.join("    ");
+
+            fs.writeSync(fd, file);
+            fs.closeSync(fd);
+        }
+    }
+
+}
+
+namespace('build', function() {
+
+    task('lint', {
+        async: true
+    }, function() {
+
+        // I looked into options and there are many for C# and C++, though simply want to catch tabs/spaces right now
+        // and not introduce a dependency, soooooo
+
+        pattern = [ atomicRoot + "Source/**/*.cpp",
+                    atomicRoot + "Source/**/*.h",
+                    atomicRoot + "Script/AtomicNET/**/*.cs"
+                 ];
+
+        pattern = "{" + pattern.join(",") + "}";
+
+        // I failed at figure out glob exclusion patterns
+        exclude = [atomicRoot + "Source/ThirdParty/",
+                   atomicRoot + "Source/ToolCore/JSBind/cplusplus/"];
+
+        var filenames = glob.sync(pattern);
+
+        for (var i = 0; i < filenames.length; i++) {
+
+            var filename = filenames[i];
+
+            var skip = false;
+
+            for (var j = 0; j < exclude.length; j++) {
+
+                if (filename.startsWith(exclude[j])) {
+                    skip = true;
+                    break;
+                }
+            }
+
+            if (skip)
+                continue;
+
+            lintFile(filename);
+        }
+
+
+        process.exit(0);
+        complete();
+
+    });
+
+}); // end of build namespace

Build/Scripts/Host.js

@@ -16,3 +16,4 @@ require("./BuildAndroid");
 require("./BuildIOS");
 require("./BuildWeb");
 require("./BuildAtomicNET");
+require("./BuildLint");

Build/Scripts/Minimist.js

@@ -1,235 +0,0 @@
-module.exports = function (args, opts) {
-    if (!opts) opts = {};
-
-    var flags = { bools : {}, strings : {}, unknownFn: null };
-
-    if (typeof opts['unknown'] === 'function') {
-        flags.unknownFn = opts['unknown'];
-    }
-
-    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
-      flags.allBools = true;
-    } else {
-      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-          flags.bools[key] = true;
-      });
-    }
-
-    var aliases = {};
-    Object.keys(opts.alias || {}).forEach(function (key) {
-        aliases[key] = [].concat(opts.alias[key]);
-        aliases[key].forEach(function (x) {
-            aliases[x] = [key].concat(aliases[key].filter(function (y) {
-                return x !== y;
-            }));
-        });
-    });
-
-    [].concat(opts.string).filter(Boolean).forEach(function (key) {
-        flags.strings[key] = true;
-        if (aliases[key]) {
-            flags.strings[aliases[key]] = true;
-        }
-     });
-
-    var defaults = opts['default'] || {};
-
-    var argv = { _ : [] };
-    Object.keys(flags.bools).forEach(function (key) {
-        setArg(key, defaults[key] === undefined ? false : defaults[key]);
-    });
-
-    var notFlags = [];
-
-    if (args.indexOf('--') !== -1) {
-        notFlags = args.slice(args.indexOf('--')+1);
-        args = args.slice(0, args.indexOf('--'));
-    }
-
-    function argDefined(key, arg) {
-        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
-            flags.strings[key] || flags.bools[key] || aliases[key];
-    }
-
-    function setArg (key, val, arg) {
-        if (arg && flags.unknownFn && !argDefined(key, arg)) {
-            if (flags.unknownFn(arg) === false) return;
-        }
-
-        var value = !flags.strings[key] && isNumber(val)
-            ? Number(val) : val
-        ;
-        setKey(argv, key.split('.'), value);
-
-        (aliases[key] || []).forEach(function (x) {
-            setKey(argv, x.split('.'), value);
-        });
-    }
-
-    function setKey (obj, keys, value) {
-        var o = obj;
-        keys.slice(0,-1).forEach(function (key) {
-            if (o[key] === undefined) o[key] = {};
-            o = o[key];
-        });
-
-        var key = keys[keys.length - 1];
-        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
-            o[key] = value;
-        }
-        else if (Array.isArray(o[key])) {
-            o[key].push(value);
-        }
-        else {
-            o[key] = [ o[key], value ];
-        }
-    }
-
-    function aliasIsBoolean(key) {
-      return aliases[key].some(function (x) {
-          return flags.bools[x];
-      });
-    }
-
-    for (var i = 0; i < args.length; i++) {
-        var arg = args[i];
-
-        if (/^--.+=/.test(arg)) {
-            // Using [\s\S] instead of . because js doesn't support the
-            // 'dotall' regex modifier. See:
-            // http://stackoverflow.com/a/1068308/13216
-            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-            var key = m[1];
-            var value = m[2];
-            if (flags.bools[key]) {
-                value = value !== 'false';
-            }
-            setArg(key, value, arg);
-        }
-        else if (/^--no-.+/.test(arg)) {
-            var key = arg.match(/^--no-(.+)/)[1];
-            setArg(key, false, arg);
-        }
-        else if (/^--.+/.test(arg)) {
-            var key = arg.match(/^--(.+)/)[1];
-            var next = args[i + 1];
-            if (next !== undefined && !/^-/.test(next)
-            && !flags.bools[key]
-            && !flags.allBools
-            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                setArg(key, next, arg);
-                i++;
-            }
-            else if (/^(true|false)$/.test(next)) {
-                setArg(key, next === 'true', arg);
-                i++;
-            }
-            else {
-                setArg(key, flags.strings[key] ? '' : true, arg);
-            }
-        }
-        else if (/^-[^-]+/.test(arg)) {
-            var letters = arg.slice(1,-1).split('');
-
-            var broken = false;
-            for (var j = 0; j < letters.length; j++) {
-                var next = arg.slice(j+2);
-
-                if (next === '-') {
-                    setArg(letters[j], next, arg)
-                    continue;
-                }
-
-                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
-                    setArg(letters[j], next.split('=')[1], arg);
-                    broken = true;
-                    break;
-                }
-
-                if (/[A-Za-z]/.test(letters[j])
-                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-                    setArg(letters[j], next, arg);
-                    broken = true;
-                    break;
-                }
-
-                if (letters[j+1] && letters[j+1].match(/\W/)) {
-                    setArg(letters[j], arg.slice(j+2), arg);
-                    broken = true;
-                    break;
-                }
-                else {
-                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
-                }
-            }
-
-            var key = arg.slice(-1)[0];
-            if (!broken && key !== '-') {
-                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
-                && !flags.bools[key]
-                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                    setArg(key, args[i+1], arg);
-                    i++;
-                }
-                else if (args[i+1] && /true|false/.test(args[i+1])) {
-                    setArg(key, args[i+1] === 'true', arg);
-                    i++;
-                }
-                else {
-                    setArg(key, flags.strings[key] ? '' : true, arg);
-                }
-            }
-        }
-        else {
-            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-                argv._.push(
-                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-                );
-            }
-            if (opts.stopEarly) {
-                argv._.push.apply(argv._, args.slice(i + 1));
-                break;
-            }
-        }
-    }
-
-    Object.keys(defaults).forEach(function (key) {
-        if (!hasKey(argv, key.split('.'))) {
-            setKey(argv, key.split('.'), defaults[key]);
-
-            (aliases[key] || []).forEach(function (x) {
-                setKey(argv, x.split('.'), defaults[key]);
-            });
-        }
-    });
-
-    if (opts['--']) {
-        argv['--'] = new Array();
-        notFlags.forEach(function(key) {
-            argv['--'].push(key);
-        });
-    }
-    else {
-        notFlags.forEach(function(key) {
-            argv._.push(key);
-        });
-    }
-
-    return argv;
-};
-
-function hasKey (obj, keys) {
-    var o = obj;
-    keys.slice(0,-1).forEach(function (key) {
-        o = (o[key] || {});
-    });
-
-    var key = keys[keys.length - 1];
-    return key in o;
-}
-
-function isNumber (x) {
-    if (typeof x === 'number') return true;
-    if (/^0x[0-9a-f]+$/i.test(x)) return true;
-    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
-}