feat: passing liquid to FilterImpl, closes #277

src/liquid.ts

@@ -31,7 +31,7 @@ export class Liquid {
     this.parser = new Parser(this)
     this.renderer = new Render()
     this.fs = opts.fs || fs
-    this.filters = new FilterMap(this.options.strictFilters)
+    this.filters = new FilterMap(this.options.strictFilters, this)
     this.tags = new TagMap()
 
     forOwn(builtinTags, (conf: TagImplOptions, name: string) => this.registerTag(snakeCase(name), conf))
@@ -104,7 +104,7 @@ export class Liquid {
   }
 
   public _evalValue (str: string, ctx: Context): IterableIterator<any> {
-    const value = new Value(str, this.filters)
+    const value = new Value(str, this.filters, this)
     return value.value(ctx)
   }
   public async evalValue (str: string, ctx: Context): Promise<any> {

src/parser/parser.ts

@@ -29,7 +29,7 @@ export default class Parser {
         return new Tag(token, remainTokens, this.liquid)
       }
       if (isOutputToken(token)) {
-        return new Output(token as OutputToken, this.liquid.filters)
+        return new Output(token as OutputToken, this.liquid.filters, this.liquid)
       }
       return new HTML(token)
     } catch (e) {

src/template/filter/filter-impl.ts

@@ -1,5 +1,7 @@
 import { Context } from '../../context/context'
+import { Liquid } from '../../liquid'
 
 export interface FilterImpl {
   context: Context;
+  liquid: Liquid;
 }

src/template/filter/filter-map.ts

@@ -2,11 +2,15 @@ import { FilterImplOptions } from './filter-impl-options'
 import { Filter } from './filter'
 import { FilterArg } from '../../parser/filter-arg'
 import { assert } from '../../util/assert'
+import { Liquid } from '../../liquid'
 
 export class FilterMap {
   private impls: {[key: string]: FilterImplOptions} = {}
 
-  constructor (private readonly strictFilters: boolean) {}
+  constructor (
+    private readonly strictFilters: boolean,
+    private readonly liquid: Liquid
+  ) {}
 
   get (name: string) {
     const impl = this.impls[name]
@@ -19,6 +23,6 @@ export class FilterMap {
   }
 
   create (name: string, args: FilterArg[]) {
-    return new Filter(name, this.get(name), args)
+    return new Filter(name, this.get(name), args, this.liquid)
   }
 }

src/template/filter/filter.ts

@@ -3,23 +3,26 @@ import { Context } from '../../context/context'
 import { identify } from '../../util/underscore'
 import { FilterImplOptions } from './filter-impl-options'
 import { FilterArg, isKeyValuePair } from '../../parser/filter-arg'
+import { Liquid } from '../../liquid'
 
 export class Filter {
   public name: string
   public args: FilterArg[]
   private impl: FilterImplOptions
+  private liquid: Liquid
 
-  public constructor (name: string, impl: FilterImplOptions, args: FilterArg[]) {
+  public constructor (name: string, impl: FilterImplOptions, args: FilterArg[], liquid: Liquid) {
     this.name = name
     this.impl = impl || identify
     this.args = args
+    this.liquid = liquid
   }
   public * render (value: any, context: Context) {
     const argv: any[] = []
     for (const arg of this.args as FilterArg[]) {
       if (isKeyValuePair(arg)) argv.push([arg[0], yield evalToken(arg[1], context)])
       else argv.push(yield evalToken(arg, context))
     }
-    return yield this.impl.apply({ context }, [value, ...argv])
+    return yield this.impl.apply({ context, liquid: this.liquid }, [value, ...argv])
   }
 }

src/template/output.ts

@@ -6,12 +6,13 @@ import { Template } from '../template/template'
 import { Context } from '../context/context'
 import { Emitter } from '../render/emitter'
 import { OutputToken } from '../tokens/output-token'
+import { Liquid } from '../liquid'
 
 export class Output extends TemplateImpl<OutputToken> implements Template {
   private value: Value
-  public constructor (token: OutputToken, filters: FilterMap) {
+  public constructor (token: OutputToken, filters: FilterMap, liquid: Liquid) {
     super(token)
-    this.value = new Value(token.content, filters)
+    this.value = new Value(token.content, filters, liquid)
   }
   public * render (ctx: Context, emitter: Emitter) {
     const val = yield this.value.value(ctx)

src/template/value.ts

@@ -5,6 +5,7 @@ import { Filter } from './filter/filter'
 import { Context } from '../context/context'
 import { ValueToken } from '../tokens/value-token'
 import { assert } from '../util/assert'
+import { Liquid } from '../liquid'
 
 export class Value {
   public readonly filters: Filter[] = []
@@ -13,15 +14,15 @@ export class Value {
   /**
    * @param str the value to be valuated, eg.: "foobar" | truncate: 3
    */
-  public constructor (str: string, private readonly filterMap: FilterMap) {
+  public constructor (str: string, private readonly filterMap: FilterMap, liquid: Liquid) {
     const tokenizer = new Tokenizer(str)
     this.initial = tokenizer.readValue()
-    this.filters = tokenizer.readFilters().map(({ name, args }) => new Filter(name, this.filterMap.get(name), args))
+    this.filters = tokenizer.readFilters().map(({ name, args }) => new Filter(name, this.filterMap.get(name), args, liquid))
   }
   public * value (ctx: Context) {
     assert(ctx, () => 'unable to evaluate: context not defined')
-    const lenient = ctx.opts.lenientIf && this.filters.length > 0 && this.filters[0].name == "default"
-    
+    const lenient = ctx.opts.lenientIf && this.filters.length > 0 && this.filters[0].name === 'default'
+
     let val = yield evalToken(this.initial, ctx, lenient)
     for (const filter of this.filters) {
       val = yield filter.render(val, ctx)

test/e2e/issues.ts

@@ -54,4 +54,15 @@ describe('Issues', function () {
     const html = engine.parseAndRenderSync(template, { condition1: true, condition2: true })
     expect(html).to.equal('<div>Y</div>')
   })
+  it('#277 Passing liquid in FilterImpl', () => {
+    const engine = new Liquid()
+    engine.registerFilter('render', function (template: string, name: string) {
+      return this.liquid.parseAndRenderSync(decodeURIComponent(template), { name })
+    })
+    const html = engine.parseAndRenderSync(
+      `{{ subtemplate | render: "foo" }}`,
+      { subtemplate: encodeURIComponent('hello {{ name }}') }
+    )
+    expect(html).to.equal('hello foo')
+  })
 })

test/unit/template/filter/filter.ts

@@ -14,8 +14,9 @@ const expect = chai.expect
 describe('filter', function () {
   let ctx: Context
   let filters: FilterMap
+  const liquid = {} as any
   beforeEach(function () {
-    filters = new FilterMap(false)
+    filters = new FilterMap(false, liquid)
     ctx = new Context()
   })
   it('should create default filter if not registered', async function () {
@@ -34,12 +35,13 @@ describe('filter', function () {
     await toThenable(filters.create('foo', [thirty]).render('foo', ctx))
     expect(spy).to.have.been.calledWith('foo', 30)
   })
-  it('should call filter impl with correct this arg', async function () {
+  it('should call filter impl with correct this', async function () {
     const spy = sinon.spy()
     filters.set('foo', spy)
     const thirty = new NumberToken(new IdentifierToken('33', 0, 2), undefined)
     await toThenable(filters.create('foo', [thirty]).render('foo', ctx))
     expect(spy).to.have.been.calledOn(sinon.match.has('context', ctx))
+    expect(spy).to.have.been.calledOn(sinon.match.has('liquid', liquid))
   })
   it('should render a simple filter', async function () {
     filters.set('upcase', x => x.toUpperCase())

test/unit/template/output.ts

@@ -9,35 +9,36 @@ const expect = chai.expect
 
 describe('Output', function () {
   const emitter: any = { write: (html: string) => (emitter.html += html), html: '' }
+  const liquid = {} as any
   let filters: FilterMap
   beforeEach(function () {
-    filters = new FilterMap(false)
+    filters = new FilterMap(false, liquid)
     emitter.html = ''
   })
 
   it('should stringify objects', async function () {
     const scope = new Context({
       foo: { obj: { arr: ['a', 2] } }
     })
-    const output = new Output({ content: 'foo' } as OutputToken, filters)
+    const output = new Output({ content: 'foo' } as OutputToken, filters, liquid)
     await toThenable(output.render(scope, emitter))
     return expect(emitter.html).to.equal('[object Object]')
   })
   it('should skip function property', async function () {
     const scope = new Context({ obj: { foo: 'foo', bar: (x: any) => x } })
-    const output = new Output({ content: 'obj' } as OutputToken, filters)
+    const output = new Output({ content: 'obj' } as OutputToken, filters, liquid)
     await toThenable(output.render(scope, emitter))
     return expect(emitter.html).to.equal('[object Object]')
   })
   it('should respect to .toString()', async () => {
     const scope = new Context({ obj: { toString: () => 'FOO' } })
-    const output = new Output({ content: 'obj' } as OutputToken, filters)
+    const output = new Output({ content: 'obj' } as OutputToken, filters, liquid)
     await toThenable(output.render(scope, emitter))
     return expect(emitter.html).to.equal('FOO')
   })
   it('should respect to .toString()', async () => {
     const scope = new Context({ obj: { toString: () => 'FOO' } })
-    const output = new Output({ content: 'obj' } as OutputToken, filters)
+    const output = new Output({ content: 'obj' } as OutputToken, filters, liquid)
     await toThenable(output.render(scope, emitter))
     return expect(emitter.html).to.equal('FOO')
   })

test/unit/template/value.ts

@@ -12,15 +12,17 @@ chai.use(sinonChai)
 const expect = chai.expect
 
 describe('Value', function () {
+  const liquid = {} as any
+
   describe('#constructor()', function () {
-    const filterMap = new FilterMap(false)
+    const filterMap = new FilterMap(false, liquid)
     it('should parse "foo', function () {
-      const tpl = new Value('foo', filterMap)
+      const tpl = new Value('foo', filterMap, liquid)
       expect(tpl.initial!.getText()).to.equal('foo')
       expect(tpl.filters).to.deep.equal([])
     })
     it('should parse filters in value content', function () {
-      const f = new Value('o | foo: a: "a"', filterMap)
+      const f = new Value('o | foo: a: "a"', filterMap, liquid)
       expect(f.filters[0].name).to.equal('foo')
       expect(f.filters[0].args).to.have.lengthOf(1)
       const [k, v] = f.filters[0].args[0] as any
@@ -34,10 +36,10 @@ describe('Value', function () {
     it('should call chained filters correctly', async function () {
       const date = sinon.stub().returns('y')
       const time = sinon.spy()
-      const filterMap = new FilterMap(false)
+      const filterMap = new FilterMap(false, liquid)
       filterMap.set('date', date)
       filterMap.set('time', time)
-      const tpl = new Value('foo.bar | date: "b" | time:2', filterMap)
+      const tpl = new Value('foo.bar | date: "b" | time:2', filterMap, liquid)
       const scope = new Context({
         foo: { bar: 'bar' }
       })