refactor: static strict_filters, disable settigns when rendering

index.js

@@ -9,7 +9,7 @@ const Render = require('./src/render.js');
 const lexical = require('./src/lexical.js');
 const Tag = require('./src/tag.js');
 const Filter = require('./src/filter.js');
-const Template = require('./src/parser');
+const Parser = require('./src/parser');
 const Syntax = require('./src/syntax.js');
 const tags = require('./tags');
 const filters = require('./filters');
@@ -25,7 +25,7 @@ var _engine = {
         this.options = options;
         this.tag = tag;
         this.filter = filter;
-        this.parser = Template(tag, filter);
+        this.parser = Parser(tag, filter);
         this.renderer = Render();
 
         tags(this);
@@ -127,7 +127,7 @@ function factory(options) {
 
     var engine = Object.create(_engine);
 
-    engine.init(Tag(), Filter(), options);
+    engine.init(Tag(), Filter(options), options);
     return engine;
 }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "shopify-liquid",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "Liquid template engine for JavaScript, Node.js and Browser",
   "main": "index.js",
   "scripts": {

src/filter.js

@@ -1,10 +1,12 @@
 const lexical = require('./lexical.js');
 const Syntax = require('./syntax.js');
 const assert = require('./util/assert.js');
+const _ = require('./util/underscore.js');
 
 var valueRE = new RegExp(`${lexical.value.source}`, 'g');
 
-module.exports = function() {
+module.exports = function(options) {
+    options = _.assign({}, options);
     var filters = {};
 
     var _filterInstance = {
@@ -19,10 +21,17 @@ module.exports = function() {
 
             var name = match[1], argList = match[2] || '', filter = filters[name];
             if (typeof filter !== 'function'){
-                return {
+                if(options.strict_filters){
-                    name: name,
+                    throw new TypeError(`undefined filter: ${name}`);
-                    error: new TypeError(`undefined filter: ${name}`)
+                }
-                };
+                this.name= name;
+                this.filter= x => x;
+                this.args= [];
+                return this;
+                //return {
+                    //name: name,
+                    //error: new TypeError(`undefined filter: ${name}`)
+                //};
             }
 
             var args = [];

src/render.js

@@ -49,19 +49,9 @@ var render = {
 
     evalOutput: function(template, scope) {
         assert(scope, 'unable to evalOutput: scope undefined');
-        var val = Syntax.evalExp(template.initial, scope);
+        return template.filters.reduce(
-        template.filters.some(filter => {
+            (prev, filter) => filter.render(prev, scope),
-            if (filter.error) {
+            Syntax.evalExp(template.initial, scope));
-                if (scope.get('liquid.strict_filters')) {
-                    throw filter.error;
-                } else { 
-                    val = '';
-                    return true;
-                }
-            }
-            val = filter.render(val, scope);
-        });
-        return val;
     }
 };
 

test/filter.js

@@ -14,10 +14,9 @@ describe('filter', function() {
         filter.clear();
         scope = Scope.factory();
     });
-    it('should return undefined when not registered', function() {
+    it('should return default filter when not registered', function() {
         var result = filter.construct('foo');
         expect(result.name).to.equal('foo');
-        expect(result.error).to.be.an('Error');
     });
 
     it('should throw when filter name illegal', function() {

test/liquid.js

@@ -5,7 +5,7 @@ const mock = require('mock-fs');
 chai.use(require("chai-as-promised"));
 
 describe('liquid', function() {
-    var engine, ctx;
+    var engine, strictEngine, ctx;
     beforeEach(function() {
         ctx = {
             name: 'harttle',
@@ -18,6 +18,11 @@ describe('liquid', function() {
             root: '/root/',
             extname: '.html'
         });
+        strictEngine = Liquid({
+            root: '/root',
+            extname: '.html',
+            strict_filters: true
+        });
         mock({
             '/root/files/foo.html': 'foo',
             '/root/files/name.html': 'My name is {{name}}.',
@@ -40,13 +45,10 @@ describe('liquid', function() {
             return engine.parseAndRender('foo{{zzz}}bar', ctx).should.eventually.equal('foobar');
         });
         it('should render as null when filter undefined', function() {
-            return engine.parseAndRender('{{arr | filter1}}', ctx).should.eventually.equal('');
+            return engine.parseAndRender('{{"foo" | filter1}}', ctx).should.eventually.equal('foo');
         });
         it('should throw upon undefined filter when strict_filters set', function() {
-            var opts = {
+            return expect(strictEngine.parseAndRender('{{arr | filter1}}', ctx)).to
-                strict_filters: true
-            };
-            return expect(engine.parseAndRender('{{arr | filter1}}', ctx, opts)).to
                 .be.rejectedWith(/undefined filter: filter1/);
         });
     });

test/util/error.js

@@ -130,14 +130,6 @@ describe('error', function() {
                     expect(e.message).to.contain('undefined variable: a');
                 });
         });
-        it('should throw RenderError when filter not defined', function() {
-            return expect(strictEngine.parseAndRender('{{1 | a}}')).to.eventually
-                .be.rejected
-                .then(function(e) {
-                    expect(e).to.have.property('name', 'RenderError');
-                    expect(e.message).to.contain('undefined filter: a');
-                });
-        });
         it('should contain template content in err.message', function() {
             var html = ['1st', '2nd', '3rd', 'X{%throwingTag%} Y', '5th', '6th', '7th'];
             var message = [
@@ -207,6 +199,14 @@ describe('error', function() {
                 }
             });
         });
+        it('should throw RenderError when filter not defined', function() {
+            return expect(strictEngine.parseAndRender('{{1 | a}}')).to.eventually
+                .be.rejected
+                .then(function(e) {
+                    expect(e).to.have.property('name', 'ParseError');
+                    expect(e.message).to.contain('undefined filter: a');
+                });
+        });
         it('should throw ParseError when tag not closed', function() {
             return expect(engine.parseAndRender('{% if %}')).to.eventually
                 .be.rejected