refact(templateFinder): now call getFinder() to get the actual function

This change allows the templateFinder to be configured before getting the
actual function.

Author: petebacondarwin

base/services/templateFinder.js

@@ -12,83 +12,72 @@ module.exports = function templateFinder(log) {
   return {
 
     /**
-     * Set the list of glob that will be searched for matching templates
-     * @param {string[]} templateFolders A collection of folders to search for templates. The templateFinder
-     *                                   will also search all subfolders.
+     * A collection of folders to search for templates. The templateFinder will also search all
+     * subfolders.
      */
-    setTemplateFolders: function(templateFolders) {
+    templateFolders: [],
+
+    /**
+     * A collection of patterns to use to match templates against documents. The patterns are
+     * expanded using lodash template interpolation, by passing in the document to match as `doc`.
+     */
+    templatePatterns: [],
 
-      if ( !templateFolders || !templateFolders.length ) {
-        throw new Error('You must provide at least one template folder');
-      }
+
+    getFinder: function() {
 
       // Traverse each templateFolder and store an index of the files found for later
-      this.templateSets = _.map(templateFolders, function(templateFolder) {
+      var templateSets = _.map(this.templateFolders, function(templateFolder) {
         return {
           templateFolder: templateFolder,
           templates: _.indexBy(glob.sync('**/*', { cwd: templateFolder }))
         };
       });
-    },
-
-    /**
-     * Set the list of patterns that will be used to match documents to templates
-     * @param {string[]} templatePatterns A collection of patterns to use to match templates against
-     *                                    documents. The patterns are expanded using lodash template
-     *                                    interpolation, by passing in the document to match as `doc`.
-     */
-    setTemplatePatterns: function(templatePatterns) {
-
-      if ( !templatePatterns || !templatePatterns.length ) {
-        throw new Error('You must provide at least one template pattern');
-      }
 
       // Compile each of the patterns and store them for later
-      this.patternMatchers = _.map(templatePatterns, function(pattern) {
+      var patternMatchers = _.map(this.templatePatterns, function(pattern) {
 
         // Here we use the lodash micro templating.
         // The document will be available to the micro template as a `doc` variable
         return _.template(pattern, null, { variable: 'doc' });
       });
 
-    },
-
-
-    /**
-     * Find the path to a template for the specified documents
-     * @param  {Object} doc The document for which to find a template
-     * @return {string}     The path to the matched template
-     */
-    findTemplate: function(doc) {
-      var templatePath;
+      /**
+       * Find the path to a template for the specified documents
+       * @param  {Object} doc The document for which to find a template
+       * @return {string}     The path to the matched template
+       */
+      return function findTemplate(doc) {
+        var templatePath;
 
-      // Search the template sets for a matching pattern for the given doc
-      _.any(this.templateSets, function(templateSet) {
-        return _.any(this.patternMatchers, function(patternMatcher) {
-          log.silly('looking for ', patternMatcher(doc));
-          templatePath = templateSet.templates[patternMatcher(doc)];
-          if ( templatePath ) {
-            log.debug('template found', path.resolve(templateSet.templateFolder, templatePath));
-            return true;
-          }
-        }, this);
-      }, this);
+        // Search the template sets for a matching pattern for the given doc
+        _.any(templateSets, function(templateSet) {
+          return _.any(patternMatchers, function(patternMatcher) {
+            log.silly('looking for ', patternMatcher(doc));
+            templatePath = templateSet.templates[patternMatcher(doc)];
+            if ( templatePath ) {
+              log.debug('template found', path.resolve(templateSet.templateFolder, templatePath));
+              return true;
+            }
+          });
+        });
 
-      if ( !templatePath ) {
-        throw new Error(
-          'No template found for "' + (doc.id || doc.name || doc.docType) + '" document.\n' +
-          'The following template patterns were tried:\n' +
-          _.reduce(this.patternMatchers, function(str, pattern) {
-            return str + '  "' + pattern(doc) + '"\n';
-          }, '') +
-          'The following folders were searched:\n' +
-          _.reduce(this.templateSets, function(str, templateSet) {
-            return str + '  "' + templateSet.templateFolder + '"\n';
-          }, '')
-        );
-      }
+        if ( !templatePath ) {
+          throw new Error(
+            'No template found for "' + (doc.id || doc.name || doc.docType) + '" document.\n' +
+            'The following template patterns were tried:\n' +
+            _.reduce(this.patternMatchers, function(str, pattern) {
+              return str + '  "' + pattern(doc) + '"\n';
+            }, '') +
+            'The following folders were searched:\n' +
+            _.reduce(this.templateSets, function(str, templateSet) {
+              return str + '  "' + templateSet.templateFolder + '"\n';
+            }, '')
+          );
+        }
 
-      return templatePath;
+        return templatePath;
+      };
     }
   };
 };

base/spec/services/templateFinder.spec.js

@@ -10,39 +10,10 @@ describe("templateFinder", function() {
     templateFinder = templateFinderFactory(mockLog);
   });
 
-  describe("setTemplateFolders()", function() {
 
-    it("should complain if no template folders were provided", function() {
+  describe("getFinder", function() {
 
-      expect(function() {
-        templateFinder.setTemplateFolders(null);
-      }).toThrow();
-
-      expect(function() {
-        templateFinder.setTemplateFolders([]);
-      }).toThrow();
-
-    });
-  });
-
-  describe("setTemplatePatterns()", function() {
-
-    it("should complain if no template patterns were provided", function() {
-
-      expect(function() {
-        templateFinder.setTemplatePatterns(null);
-      }).toThrow();
-
-      expect(function() {
-        templateFinder.setTemplatePatterns([]);
-      }).toThrow();
-
-    });
-  });
-
-  describe("findTemplate", function() {
-
-    var glob, patterns, templateFolders;
+    var glob, patterns, templateFolders, findTemplate;
 
     beforeEach(function() {
       glob = templateFinderFactory.__get__('glob');
@@ -56,34 +27,36 @@ describe("templateFinder", function() {
       ];
       templateFolders = ['abc'];
 
-      templateFinder.setTemplateFolders(templateFolders);
-      templateFinder.setTemplatePatterns(patterns);
+      templateFinder.templateFolders = templateFolders;
+      templateFinder.templatePatterns = patterns;
+
+      findTemplate = templateFinder.getFinder();
     });
 
 
     it("should match id followed by doctype if both are provided and the file exists", function() {
-      expect(templateFinder.findTemplate({ docType: 'a', id: 'c'})).toEqual('c.a.x');
+      expect(findTemplate({ docType: 'a', id: 'c'})).toEqual('c.a.x');
     });
 
 
     it("should match id before docType", function() {
-      expect(templateFinder.findTemplate({ docType: 'a', id: 'b' })).toEqual('b.x');
+      expect(findTemplate({ docType: 'a', id: 'b' })).toEqual('b.x');
     });
 
 
     it("should match docType if id doesn't match", function() {
-      expect(templateFinder.findTemplate({ docType: 'a', id: 'missing' })).toEqual('a.x');
+      expect(findTemplate({ docType: 'a', id: 'missing' })).toEqual('a.x');
     });
 
 
     it("should match docType if id is undefined", function() {
-      expect(templateFinder.findTemplate({ docType: 'a' })).toEqual('a.x');
+      expect(findTemplate({ docType: 'a' })).toEqual('a.x');
     });
 
 
     it("should throw an error if no template was found", function() {
       expect(function() {
-        templateFinder.findTemplate({docType:'missing'});
+        findTemplate({docType:'missing'});
       }).toThrow();
     });