shibori 1.0.0.beta1

data/builder/pattern_assembler.js

@@ -0,0 +1,258 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+  "use strict";
+
+  var pattern_assembler = function(){
+
+    function isObjectEmpty(obj) {
+      for(var prop in obj) {
+          if(obj.hasOwnProperty(prop))
+              return false;
+      }
+
+      return true;
+    }
+
+
+    //find and return any {{> template-name }} within pattern
+    function findPartials(pattern){
+      var matches = pattern.template.match(/{{>([ ])?([\w\-\.\/~]+)(?:\:[A-Za-z0-9-]+)?(?:(| )\(.*)?([ ])?}}/g);
+      return matches;
+    }
+
+    function findListItems(pattern){
+      var matches = pattern.template.match(/({{#( )?)(listItems.)(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)( )?}}/g);
+      return matches;
+    }
+
+    function setState(pattern, patternlab){
+      if(patternlab.config.patternStates[pattern.patternName]){
+        pattern.patternState = patternlab.config.patternStates[pattern.patternName];
+      } else{
+        pattern.patternState = "";
+      }
+    }
+
+    function addPattern(pattern, patternlab){
+      patternlab.data.link[pattern.patternGroup + '-' + pattern.patternName] = '/patterns/' + pattern.patternLink;
+      patternlab.patterns.push(pattern);
+    }
+
+    function renderPattern(template, data, partials) {
+
+      var mustache = require('mustache');
+
+      if(partials) {
+        return mustache.render(template, data, partials);
+      } else{
+        return mustache.render(template, data);
+      }
+    }
+
+    function processPatternFile(file, patternlab){
+      var fs = require('fs-extra'),
+      of = require('./object_factory'),
+      path = require('path');
+
+      //extract some information
+      var abspath = file.substring(2);
+      var subdir = path.dirname(path.relative(patternlab.config.patterns.source, file)).replace('\\', '/');
+      var filename = path.basename(file);
+
+      //ignore _underscored patterns, json (for now), and dotfiles
+      if(filename.charAt(0) === '_' || path.extname(filename) === '.json' || filename.charAt(0) === '.'){
+        return;
+      }
+
+      //make a new Pattern Object
+      var currentPattern = new of.oPattern(subdir, filename);
+
+      //see if this file has a state
+      setState(currentPattern, patternlab);
+
+      //look for a json file for this template
+      try {
+        var jsonFilename = patternlab.config.patterns.source + currentPattern.subdir + '/' + currentPattern.fileName  + ".json";
+        currentPattern.jsonFileData = fs.readJSONSync(jsonFilename.substring(2));
+        console.log('found pattern-specific data.json for ' + currentPattern.key);
+      }
+      catch(e) {
+      }
+
+      //look for a listitems.json file for this template
+      try {
+        var listJsonFileName = patternlab.config.patterns.source + currentPattern.subdir + '/' + currentPattern.fileName  + ".listitems.json";
+        currentPattern.patternSpecificListJson = fs.readJSONSync(listJsonFileName.substring(2));
+        console.log('found pattern-specific listitems.json for ' + currentPattern.key);
+      }
+      catch(e) {
+      }      
+
+      //add the raw template to memory
+      currentPattern.template = fs.readFileSync(abspath, 'utf8');
+
+      //our helper function that does a lot of heavy lifting
+      processPattern(currentPattern, patternlab);
+    }
+
+    function processPattern(currentPattern, patternlab, additionalData){
+
+      var fs = require('fs-extra'),
+      mustache = require('mustache'),
+      lh = require('./lineage_hunter'),
+      ph = require('./parameter_hunter'),
+      pph = require('./pseudopattern_hunter'),
+      lih = require('./list_item_hunter'),
+      path = require('path');
+
+      var parameter_hunter = new ph(),
+      lineage_hunter = new lh(),
+      list_item_hunter = new lih(),
+      pseudopattern_hunter = new pph();
+
+      currentPattern.extendedTemplate = currentPattern.template;
+
+      //find how many partials there may be for the given pattern
+      var foundPatternPartials = findPartials(currentPattern);
+
+      if(foundPatternPartials !== null && foundPatternPartials.length > 0){
+
+        if(patternlab.config.debug){
+          console.log('found partials for ' + currentPattern.key);
+        }
+
+        //find any listItem partials
+        list_item_hunter.process_list_item_partials(currentPattern, patternlab);
+
+        //determine if the template contains any pattern parameters. if so they must be immediately consumed
+        parameter_hunter.find_parameters(currentPattern, patternlab);
+
+        //do something with the regular old partials
+        for(var i = 0; i < foundPatternPartials.length; i++){
+          var partialKey = foundPatternPartials[i].replace(/{{>([ ])?([\w\-\.\/~]+)(?:\:[A-Za-z0-9-]+)?(?:(| )\(.*)?([ ])?}}/g, '$2');
+          var partialPattern = getpatternbykey(partialKey, patternlab);
+          currentPattern.extendedTemplate = currentPattern.extendedTemplate.replace(foundPatternPartials[i], partialPattern.extendedTemplate);
+        }
+
+      }
+
+      //find pattern lineage
+      lineage_hunter.find_lineage(currentPattern, patternlab);
+
+      //look for a pseudo pattern by checking if there is a file containing same name, with ~ in it, ending in .json
+      pseudopattern_hunter.find_pseudopatterns(currentPattern, patternlab);
+
+      //add to patternlab object so we can look these up later.
+      addPattern(currentPattern, patternlab);
+    }
+
+    function getpatternbykey(key, patternlab){
+      for(var i = 0; i < patternlab.patterns.length; i++){
+        switch(key){
+          case patternlab.patterns[i].key:
+          case patternlab.patterns[i].subdir + '/' + patternlab.patterns[i].fileName:
+          case patternlab.patterns[i].subdir + '/' + patternlab.patterns[i].fileName + '.mustache':
+            return patternlab.patterns[i];
+        }
+      }
+      throw 'Could not find pattern with key ' + key;
+    }
+
+    
+    var self = this;
+    function mergeData(obj1, obj2) {
+      for (var p in obj2) {
+        try {
+          // Property in destination object set; update its value.
+          if ( obj2[p].constructor == Object ) {
+            obj1[p] = self.merge_data(obj1[p], obj2[p]);
+
+          } else {
+            obj1[p] = obj2[p];
+          }
+        } catch(e) {
+          // Property in destination object not set; create it and set its value.
+          obj1[p] = obj2[p];
+        }
+      }
+      return obj1;
+    }
+
+    function buildListItems(patternlab){
+      //combine all list items into one structure
+      var list = [];
+      for (var item in patternlab.listitems) {
+        if( patternlab.listitems.hasOwnProperty(item)) {
+          list.push(patternlab.listitems[item]);
+        }
+      }
+      patternlab.listItemArray = shuffle(list);
+
+      for(var i = 1; i <= patternlab.listItemArray.length; i++){
+        var tempItems = [];
+        if( i === 1){
+          tempItems.push(patternlab.listItemArray[0]);
+          patternlab.listitems['' + i ] = tempItems;
+        } else{
+          for(var c = 1; c <= i; c++){
+            tempItems.push(patternlab.listItemArray[c - 1]);
+            patternlab.listitems['' + i ] = tempItems;
+          }
+        }
+      }
+    }
+
+    //http://stackoverflow.com/questions/6274339/how-can-i-shuffle-an-array-in-javascript
+    function shuffle(o){
+        for(var j, x, i = o.length; i; j = Math.floor(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
+        return o;
+    }
+
+    return {
+      find_pattern_partials: function(pattern){
+        return findPartials(pattern);
+      },
+      find_list_items: function(pattern){
+        return findListItems(pattern)
+      },
+      setPatternState: function(pattern, patternlab){
+        setState(pattern, patternlab);
+      },
+      addPattern: function(pattern, patternlab){
+        addPattern(pattern, patternlab);
+      },
+      renderPattern: function(template, data, partials){
+        return renderPattern(template, data, partials);
+      },
+      process_pattern_file: function(file, patternlab){
+        processPatternFile(file, patternlab);
+      },
+      process_pattern: function(pattern, patternlab, additionalData){
+        processPattern(pattern, patternlab, additionalData);
+      },
+      get_pattern_by_key: function(key, patternlab){
+        return getpatternbykey(key, patternlab);
+      },
+      merge_data: function(existingData, newData){
+        return mergeData(existingData, newData);
+      },
+      combine_listItems: function(patternlab){
+        buildListItems(patternlab);
+      },
+      is_object_empty: function(obj){
+        return isObjectEmpty(obj);
+      }
+    };
+
+  };
+
+  module.exports = pattern_assembler;
+
+}());

data/builder/pattern_exporter.js

@@ -0,0 +1,43 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+  "use strict";
+
+  var fs = require('fs-extra'),
+  path = require('path');
+
+  var pattern_exporter = function(){
+
+    function exportPatterns(patternlab){
+
+      //read the config export options
+      var exportKeys = patternlab.config.patternExportKeys;
+
+      //find the chosen patterns to export
+      for (var i = 0; i < exportKeys.length; i++){
+        for (var j = 0; j < patternlab.patterns.length; j++){
+          if(exportKeys[i] === patternlab.patterns[j].key){
+            //write matches to the desired location
+            fs.outputFileSync(patternlab.config.patternExportDirectory + patternlab.patterns[j].key + '.html', patternlab.patterns[j].patternPartial);
+          }
+        }
+      }
+    }
+
+    return {
+      export_patterns: function(patternlab){
+        exportPatterns(patternlab);
+      }
+    };
+
+  };
+
+  module.exports = pattern_exporter;
+
+}());

data/builder/patternlab.js

@@ -0,0 +1,365 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/var patternlab_engine = function () {
+  'use strict';
+
+  var path = require('path'),
+  fs = require('fs-extra'),
+  extend = require('util')._extend,
+  diveSync = require('diveSync'),
+  mustache = require('mustache'),
+  glob = require('glob'),
+  of = require('./object_factory'),
+  pa = require('./pattern_assembler'),
+  mh = require('./media_hunter'),
+  pe = require('./pattern_exporter'),
+  he = require('html-entities').AllHtmlEntities,
+  patternlab = {};
+
+  patternlab.package = fs.readJSONSync('./package.json');
+  patternlab.config = fs.readJSONSync('./config.json');
+
+  function getVersion() {
+    console.log(patternlab.package.version);
+  }
+
+  function help(){
+    console.log('Patternlab Node Help');
+    console.log('===============================');
+    console.log('Command Line Arguments');
+    console.log('patternlab:only_patterns');
+    console.log(' > Compiles the patterns only, outputting to config.patterns.public');
+    console.log('patternlab:v');
+    console.log(' > Retrieve the version of patternlab-node you have installed');
+    console.log('patternlab:help');
+    console.log(' > Get more information about patternlab-node, pattern lab in general, and where to report issues.');
+    console.log('===============================');
+    console.log('Visit http://patternlab.io/docs/index.html for general help on pattern-lab');
+    console.log('Visit https://github.com/pattern-lab/patternlab-node/issues to open a bug.');
+  }
+
+  function printDebug() {
+    //debug file can be written by setting flag on config.json
+    if(patternlab.config.debug){
+      console.log('writing patternlab debug file to ./patternlab.json');
+      fs.outputFileSync('./patternlab.json', JSON.stringify(patternlab, null, 3));
+    }
+  }
+
+  function buildPatterns(deletePatternDir){
+    patternlab.data = fs.readJSONSync('./source/_data/data.json');
+    patternlab.listitems = fs.readJSONSync('./source/_data/listitems.json');
+    patternlab.header = fs.readFileSync('./source/_patternlab-files/pattern-header-footer/header.html', 'utf8');
+    patternlab.footer = fs.readFileSync('./source/_patternlab-files/pattern-header-footer/footer.html', 'utf8');
+    patternlab.patterns = [];
+    patternlab.partials = {};
+    patternlab.data.link = {};
+
+    var pattern_assembler = new pa(),
+    entity_encoder = new he(),
+    pattern_exporter = new pe(),
+    patterns_dir = './source/_patterns';
+
+    pattern_assembler.combine_listItems(patternlab);
+
+    diveSync(patterns_dir, {
+      filter: function(path, dir) {
+        if(dir){
+          var remainingPath = path.replace(patterns_dir, '');
+          var isValidPath = remainingPath.indexOf('/_') === -1;
+          return isValidPath;
+        }
+          return true;
+        }
+      },
+      function(err, file){
+        //log any errors
+        if(err){
+          console.log(err);
+          return;
+        }
+
+        pattern_assembler.process_pattern_file(file, patternlab);
+    });
+
+    //delete the contents of config.patterns.public before writing
+    if(deletePatternDir){
+      fs.emptyDirSync(patternlab.config.patterns.public);
+    }
+
+    //render all patterns last, so lineageR works
+    patternlab.patterns.forEach(function(pattern, index, patterns){
+      //render the pattern, but first consolidate any data we may have
+      var allData =  JSON.parse(JSON.stringify(patternlab.data));
+      allData = pattern_assembler.merge_data(allData, pattern.jsonFileData);
+
+      pattern.patternPartial = pattern_assembler.renderPattern(pattern.extendedTemplate, allData);
+
+      //add footer info before writing
+      var patternFooter = pattern_assembler.renderPattern(patternlab.footer, pattern);
+
+      //write the compiled template to the public patterns directory
+      fs.outputFileSync(patternlab.config.patterns.public + pattern.patternLink, patternlab.header + pattern.patternPartial + patternFooter);
+
+      //write the mustache file too
+      fs.outputFileSync(patternlab.config.patterns.public + pattern.patternLink.replace('.html', '.mustache'), entity_encoder.encode(pattern.template));
+
+      //write the encoded version too
+      fs.outputFileSync(patternlab.config.patterns.public + pattern.patternLink.replace('.html', '.escaped.html'), entity_encoder.encode(pattern.patternPartial));
+    });
+
+    //export patterns if necessary
+    pattern_exporter.export_patterns(patternlab);
+
+  }
+
+  function buildFrontEnd(){
+    var pattern_assembler = new pa(),
+    media_hunter = new mh();
+    patternlab.buckets = [];
+    patternlab.bucketIndex = [];
+    patternlab.patternPaths = {};
+    patternlab.viewAllPaths = {};
+
+    //find mediaQueries
+    media_hunter.find_media_queries('./source/css', patternlab);
+
+    //build the styleguide
+    var styleguideTemplate = fs.readFileSync('./source/_patternlab-files/styleguide.mustache', 'utf8'),
+    styleguideHtml = pattern_assembler.renderPattern(styleguideTemplate, {partials: patternlab.patterns});
+    fs.outputFileSync('./public/styleguide/html/styleguide.html', styleguideHtml);
+
+    //build the viewall pages
+    var prevSubdir = '',
+    i;
+
+    for (i = 0; i < patternlab.patterns.length; i++) {
+      var pattern = patternlab.patterns[i];
+
+      // check if the current sub section is different from the previous one
+      if (pattern.subdir !== prevSubdir) {
+        prevSubdir = pattern.subdir;
+
+        var viewAllPatterns = [],
+        patternPartial = "viewall-" + pattern.patternGroup + "-" + pattern.patternSubGroup,
+        j;
+
+        for (j = 0; j < patternlab.patterns.length; j++) {
+          if (patternlab.patterns[j].subdir === pattern.subdir) {
+            viewAllPatterns.push(patternlab.patterns[j]);
+          }
+        }
+
+        var viewAllTemplate = fs.readFileSync('./source/_patternlab-files/viewall.mustache', 'utf8');
+        var viewAllHtml = pattern_assembler.renderPattern(viewAllTemplate, {partials: viewAllPatterns, patternPartial: patternPartial});
+        fs.outputFileSync(patternlab.config.patterns.public + pattern.flatPatternPath + '/index.html', viewAllHtml);
+      }
+    }
+
+    //build the patternlab website
+    var patternlabSiteTemplate = fs.readFileSync('./source/_patternlab-files/index.mustache', 'utf8');
+
+    //loop through all patterns.to build the navigation
+    //todo: refactor this someday
+    for(var i = 0; i < patternlab.patterns.length; i++){
+      var pattern = patternlab.patterns[i];
+      var bucketName = pattern.name.replace(/\\/g, '-').split('-')[1];
+
+      //check if the bucket already exists
+      var bucketIndex = patternlab.bucketIndex.indexOf(bucketName);
+      if(bucketIndex === -1){
+        //add the bucket
+        var bucket = new of.oBucket(bucketName);
+
+        //add patternPath and viewAllPath
+        patternlab.patternPaths[bucketName] = {};
+        patternlab.viewAllPaths[bucketName] = {};
+
+        //get the navItem
+        var navItemName = pattern.subdir.split('-').pop();
+
+        //get the navSubItem
+        var navSubItemName = pattern.patternName.replace(/-/g, ' ');
+
+        //test whether the pattern struture is flat or not - usually due to a template or page
+        var flatPatternItem = false;
+        if(navItemName === bucketName){
+          flatPatternItem = true;
+        }
+
+        //assume the navItem does not exist.
+        var navItem = new of.oNavItem(navItemName);
+
+        //assume the navSubItem does not exist.
+        var navSubItem = new of.oNavSubItem(navSubItemName);
+        navSubItem.patternPath = pattern.patternLink;
+        navSubItem.patternPartial = bucketName + "-" + pattern.patternName; //add the hyphenated name
+
+        //add the patternState if it exists
+        if(pattern.patternState){
+          navSubItem.patternState = pattern.patternState;
+        }
+
+        //if it is flat - we should not add the pattern to patternPaths
+        if(flatPatternItem){
+
+          bucket.patternItems.push(navSubItem);
+
+          //add to patternPaths
+          addToPatternPaths(bucketName, pattern);
+
+        } else{
+
+          bucket.navItems.push(navItem);
+          bucket.navItemsIndex.push(navItemName);
+          navItem.navSubItems.push(navSubItem);
+          navItem.navSubItemsIndex.push(navSubItemName);
+
+          //add to patternPaths
+          addToPatternPaths(bucketName, pattern);
+
+        }
+
+        //add the bucket.
+        patternlab.buckets.push(bucket);
+        patternlab.bucketIndex.push(bucketName);
+
+        //done
+
+      } else{
+        //find the bucket
+        var bucket = patternlab.buckets[bucketIndex];
+
+        //get the navItem
+        var navItemName = pattern.subdir.split('-').pop();
+
+        //get the navSubItem
+        var navSubItemName = pattern.patternName.replace(/-/g, ' ');
+
+        //assume the navSubItem does not exist.
+        var navSubItem = new of.oNavSubItem(navSubItemName);
+        navSubItem.patternPath = pattern.patternLink;
+        navSubItem.patternPartial = bucketName + "-" + pattern.patternName; //add the hyphenated name
+
+        //add the patternState if it exists
+        if(pattern.patternState){
+          navSubItem.patternState = pattern.patternState;
+        }
+
+        //test whether the pattern struture is flat or not - usually due to a template or page
+        var flatPatternItem = false;
+        if(navItemName === bucketName){
+          flatPatternItem = true;
+        }
+
+        //if it is flat - we should not add the pattern to patternPaths
+        if(flatPatternItem){
+
+          //add the navItem to patternItems
+          bucket.patternItems.push(navSubItem);
+
+          //add to patternPaths
+          addToPatternPaths(bucketName, pattern);
+
+        } else{
+          //check to see if navItem exists
+          var navItemIndex = bucket.navItemsIndex.indexOf(navItemName);
+          if(navItemIndex === -1){
+
+            var navItem = new of.oNavItem(navItemName);
+
+            //add the navItem and navSubItem
+            navItem.navSubItems.push(navSubItem);
+            navItem.navSubItemsIndex.push(navSubItemName);
+            bucket.navItems.push(navItem);
+            bucket.navItemsIndex.push(navItemName);
+
+          } else{
+            //add the navSubItem
+            var navItem = bucket.navItems[navItemIndex];
+            navItem.navSubItems.push(navSubItem);
+            navItem.navSubItemsIndex.push(navSubItemName);
+          }
+
+          //add the navViewAllSubItem
+          var navViewAllSubItem = new of.oNavSubItem("");
+          navViewAllSubItem.patternName = "View All";
+          navViewAllSubItem.patternPath = pattern.flatPatternPath + "/index.html";
+          navViewAllSubItem.patternPartial = "viewall-" + pattern.patternGroup + "-" + pattern.patternSubGroup;
+
+          //check if we are moving to a new sub section in the next loop
+          if (!patternlab.patterns[i + 1] || pattern.patternSubGroup !== patternlab.patterns[i + 1].patternSubGroup) {
+            navItem.navSubItems.push(navViewAllSubItem);
+            navItem.navSubItemsIndex.push("View All");
+          }
+
+          // just add to patternPaths
+          addToPatternPaths(bucketName, pattern);
+        }
+
+      }
+
+      patternlab.viewAllPaths[bucketName][pattern.patternSubGroup] = pattern.flatPatternPath;
+
+    }
+
+    //the patternlab site requires a lot of partials to be rendered.
+    //patternNav
+    var patternNavTemplate = fs.readFileSync('./source/_patternlab-files/partials/patternNav.mustache', 'utf8');
+    var patternNavPartialHtml = pattern_assembler.renderPattern(patternNavTemplate, patternlab);
+
+    //ishControls
+    var ishControlsTemplate = fs.readFileSync('./source/_patternlab-files/partials/ishControls.mustache', 'utf8');
+    patternlab.config.mqs = patternlab.mediaQueries;
+    var ishControlsPartialHtml = pattern_assembler.renderPattern(ishControlsTemplate, patternlab.config);
+
+    //patternPaths
+    var patternPathsTemplate = fs.readFileSync('./source/_patternlab-files/partials/patternPaths.mustache', 'utf8');
+    var patternPathsPartialHtml = pattern_assembler.renderPattern(patternPathsTemplate, {'patternPaths': JSON.stringify(patternlab.patternPaths)});
+
+    //viewAllPaths
+    var viewAllPathsTemplate = fs.readFileSync('./source/_patternlab-files/partials/viewAllPaths.mustache', 'utf8');
+    var viewAllPathsPartialHtml = pattern_assembler.renderPattern(viewAllPathsTemplate, {'viewallpaths': JSON.stringify(patternlab.viewAllPaths)});
+
+    //render the patternlab template, with all partials
+    var patternlabSiteHtml = pattern_assembler.renderPattern(patternlabSiteTemplate, {}, {
+      'ishControls': ishControlsPartialHtml,
+      'patternNav': patternNavPartialHtml,
+      'patternPaths': patternPathsPartialHtml,
+      'viewAllPaths': viewAllPathsPartialHtml
+    });
+    fs.outputFileSync('./public/index.html', patternlabSiteHtml);
+  }
+
+  function addToPatternPaths(bucketName, pattern){
+    //this is messy, could use a refactor.
+    patternlab.patternPaths[bucketName][pattern.patternName] = pattern.subdir.replace(/\\/g, '/') + "/" + pattern.fileName;
+  }
+
+  return {
+    version: function(){
+      return getVersion();
+    },
+    build: function(deletePatternDir){
+      buildPatterns(deletePatternDir);
+      buildFrontEnd();
+      printDebug();
+    },
+    help: function(){
+      help();
+    },
+    build_patterns_only: function(deletePatternDir){
+      buildPatterns(deletePatternDir);
+      printDebug();
+    }
+  };
+
+};
+
+module.exports = patternlab_engine;

data/builder/patternlab_grunt.js

@@ -0,0 +1,38 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/var patternlab_engine = require('./patternlab.js');
+
+module.exports = function(grunt) {
+	grunt.registerTask('patternlab', 'create design systems with atomic design', function(arg) {
+
+		var patternlab = patternlab_engine();
+
+		if(arguments.length === 0){
+			patternlab.build(true);
+		}
+
+		if(arg && arg === 'v'){
+			patternlab.version();
+		}
+
+		if(arg && arg === "only_patterns"){
+			patternlab.build_patterns_only(true);
+		}
+
+		if(arg && arg === "help"){
+			patternlab.help();
+		}
+
+		if(arg && (arg !== "v" && arg !=="only_patterns" && arg !=="help")){
+			patternlab.help();
+		}
+
+	});
+
+};