Underscore engine with basic support and unit tests!

Author: geoffp

builder/pattern_engines/engine_underscore.js

@@ -0,0 +1,93 @@
+/*
+ * underscore pattern engine for patternlab-node - v0.15.1 - 2015
+ *
+ * Geoffrey Pursell, Brian Muenzenmeyer, and the web community.
+ * Licensed under the MIT license.
+ *
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ *
+ */
+
+
+/*
+ * ENGINE SUPPORT LEVEL:
+ *
+ * Basic. We can't call partials from inside underscore templates yet, but we
+ * can render templates with backing JSON.
+ *
+ */
+
+(function () {
+  "use strict";
+
+  var _ = require('underscore');
+
+  // extend underscore with partial-ing methods
+  // HANDLESCORE! UNDERBARS!
+  _.mixin({
+    renderPartial: function(partial, data) {
+      var data = data || {};
+      var compiled = _.template(partial);
+      return compiled(data);
+    },
+    assignContext: function(viewModel, data) {
+      return viewModel(data);
+    }
+  });
+
+  var engine_underscore = {
+    engine: _,
+    engineName: 'underscore',
+    engineFileExtension: '.underscore',
+
+    // partial expansion is only necessary for Mustache templates that have
+    // style modifiers or pattern parameters (I think)
+    expandPartials: false,
+
+    // regexes, stored here so they're only compiled once
+    findPartialsRE: /<%= _.renderPartial\((.*?)\).*?%>/g, // TODO,
+    findPartialsWithStyleModifiersRE: /<%= _.renderPartial\((.*?)\).*?%>/g, // TODO
+    findPartialsWithPatternParametersRE: /<%= _.renderPartial\((.*?)\).*?%>/g, // TODO
+    findListItemsRE: /({{#( )?)(list(I|i)tems.)(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)( )?}}/g,
+
+    // render it
+    renderPattern: function renderPattern(template, data, partials) {
+      var compiled = _.template(template);
+      return compiled(_.extend(data, {
+        _allData: data,
+        _partials: partials
+      }));
+    },
+
+    // registerPartial: function (oPattern) {
+    //   debugger;
+    //   _.registerPartial(oPattern.key, oPattern.template);
+    // },
+
+    // find and return any {{> template-name }} within pattern
+    findPartials: function findPartials(pattern) {
+      var matches = pattern.template.match(this.findPartialsRE);
+      return matches;
+    },
+    findPartialsWithStyleModifiers: function(pattern) {
+      return [];
+    },
+    // returns any patterns that match {{> value(foo:"bar") }} or {{>
+    // value:mod(foo:"bar") }} within the pattern
+    findPartialsWithPatternParameters: function(pattern) {
+      return [];
+    },
+    findListItems: function(pattern) {
+      var matches = pattern.template.match(this.findListItemsRE);
+      return matches;
+    },
+    // given a pattern, and a partial string, tease out the "pattern key" and
+    // return it.
+    findPartialKey: function(partialString) {
+      var partialKey = partialString.replace(this.findPartialsRE, '$1');
+      return partialKey;
+    }
+  };
+
+  module.exports = engine_underscore;
+})();

test/engine_underscore_tests.js

@@ -0,0 +1,84 @@
+(function () {
+  "use strict";
+
+  var path = require('path');
+  var pa = require('../builder/pattern_assembler');
+  var testPatternsPath = path.resolve(__dirname, 'files', '_underscore-test-patterns');
+
+  try {
+    require('underscore');
+  } catch (err) {
+    console.log('underscore renderer not installed; skipping tests');
+    return;
+  }
+
+  // fake pattern lab constructor:
+  // sets up a fake patternlab object, which is needed by the pattern processing
+  // apparatus.
+  function fakePatternLab() {
+    var fpl = {
+      partials: {},
+      patterns: [],
+      footer: '',
+      header: '',
+      listitems: {},
+      listItemArray: [],
+      data: {
+        link: {}
+      },
+      config: require('../config.json'),
+      package: {}
+    };
+
+    // patch the pattern source so the pattern assembler can correctly determine
+    // the "subdir"
+    fpl.config.paths.source.patterns = testPatternsPath;
+
+    return fpl;
+  }
+
+  exports['engine_underscore'] = {
+    'hello world underscore pattern renders': function (test) {
+      test.expect(1);
+
+      var patternPath = path.resolve(
+        testPatternsPath,
+        '00-atoms',
+        '00-global',
+        '00-helloworld.underscore'
+      );
+
+      // do all the normal processing of the pattern
+      var patternlab = new fakePatternLab();
+      var assembler = new pa();
+      var helloWorldPattern = assembler.process_pattern_iterative(patternPath, patternlab);
+      assembler.process_pattern_recursive(patternPath, patternlab);
+
+      test.equals(helloWorldPattern.render(), 'Hello world!\n');
+      test.done();
+    },
+    'underscore partials can render JSON values': function (test) {
+      test.expect(1);
+
+      // pattern paths
+      var pattern1Path = path.resolve(
+        testPatternsPath,
+        '00-atoms',
+        '00-global',
+        '00-helloworld-withdata.underscore'
+      );
+
+      // set up environment
+      var patternlab = new fakePatternLab(); // environment
+      var assembler = new pa();
+
+      // do all the normal processing of the pattern
+      var helloWorldWithData = assembler.process_pattern_iterative(pattern1Path, patternlab);
+      assembler.process_pattern_recursive(pattern1Path, patternlab);
+
+      // test
+      test.equals(helloWorldWithData.render(), 'Hello world!\nYeah, we got the subtitle from the JSON.\n');
+      test.done();
+    }
+  };
+})();

test/files/_underscore-test-patterns/00-atoms/00-global/00-helloworld-withdata.json

@@ -0,0 +1,3 @@
+{
+  "subtitle": "Yeah, we got the subtitle from the JSON."
+}

test/files/_underscore-test-patterns/00-atoms/00-global/00-helloworld-withdata.underscore

@@ -0,0 +1,2 @@
+Hello world!
+<%= subtitle %>

test/files/_underscore-test-patterns/00-atoms/00-global/00-helloworld.underscore

@@ -0,0 +1 @@
+Hello world!

test/files/_underscore-test-patterns/00-molecules/00-global/00-call-atom-with-molecule-data.json

@@ -0,0 +1,6 @@
+{
+  "subtitle": "from the default JSON.",
+  "otherBlob": {
+    "subtitle": "from a totally different blob."
+  }
+}

test/files/_underscore-test-patterns/00-molecules/00-global/00-call-atom-with-molecule-data.underscore

@@ -0,0 +1,5 @@
+<h2>Call with default JSON environment:</h2>
+This is {{> atoms-helloworld-withdata }}
+
+<h2>Call with passed parameter:</h2>
+However, this is {{> atoms-helloworld-withdata otherBlob }}

test/files/_underscore-test-patterns/00-molecules/00-global/00-helloworlds.underscore

@@ -0,0 +1 @@
+<%= _.template(_partials['atoms-helloworld'])(_data) %> and <%= _.template(_partials['atoms-helloworld'])(_data) %>

test/pattern_engines_tests.js

@@ -98,9 +98,27 @@
   function testProps(object, propTests, test) {
 
     // function to test each expected property is present and the correct type
-    function testProp(propName, typeString) {
+    function testProp(propName, types) {
+
+      var possibleTypes;
+
+      // handle "types" being a string or an array of strings
+      if (types instanceof Array) {
+        possibleTypes = types;
+      } else {
+        // "types" is just a single string, load it into an array; the rest of
+        // the code expects it!
+        possibleTypes = [types];
+      }
+
+      var isOneOfTheseTypes = possibleTypes.map(function (type) {
+        return typeof object[propName] === type;
+      }).reduce(function(isPrevType, isCurrentType) {
+        return isPrevType || isCurrentType;
+      });
+      
       test.ok(object.hasOwnProperty(propName), '"' + propName + '" prop should be present');
-      test.ok(typeof object[propName] === typeString, '"' + propName + '" prop should be of type ' + typeString);
+      test.ok(isOneOfTheseTypes, '"' + propName + '" prop should be one of types ' + possibleTypes);
     }
 
     // go over each property test and run it
@@ -129,7 +147,7 @@
       'engine contains expected properties and methods': function (test) {
 
         var propertyTests = {
-          'engine': 'object',
+          'engine': ['object', 'function'],
           'engineName': 'string',
           'engineFileExtension': 'string',
           'renderPattern': 'function',