From f9f595f0f4604bfcfeabe097a01c6df6eb98baed Mon Sep 17 00:00:00 2001 From: harttle Date: Tue, 8 Dec 2020 00:04:15 +0800 Subject: [PATCH] feat: passing liquid to FilterImpl, closes #277 --- src/liquid.ts | 4 ++-- src/parser/parser.ts | 2 +- src/template/filter/filter-impl.ts | 2 ++ src/template/filter/filter-map.ts | 8 ++++++-- src/template/filter/filter.ts | 7 +++++-- src/template/output.ts | 5 +++-- src/template/value.ts | 9 +++++---- test/e2e/issues.ts | 11 +++++++++++ test/unit/template/filter/filter.ts | 6 ++++-- test/unit/template/output.ts | 11 ++++++----- test/unit/template/value.ts | 12 +++++++----- 11 files changed, 52 insertions(+), 25 deletions(-) diff --git a/src/liquid.ts b/src/liquid.ts index a19b65456e..3ee61bbf02 100644 --- a/src/liquid.ts +++ b/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 { - 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 { diff --git a/src/parser/parser.ts b/src/parser/parser.ts index 006eede249..fdbdd87474 100644 --- a/src/parser/parser.ts +++ b/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) { diff --git a/src/template/filter/filter-impl.ts b/src/template/filter/filter-impl.ts index dce65e23f6..6602b86f44 100644 --- a/src/template/filter/filter-impl.ts +++ b/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; } diff --git a/src/template/filter/filter-map.ts b/src/template/filter/filter-map.ts index 0724bae408..8ad41498d2 100644 --- a/src/template/filter/filter-map.ts +++ b/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) } } diff --git a/src/template/filter/filter.ts b/src/template/filter/filter.ts index 81c39f7960..246c4f9c79 100644 --- a/src/template/filter/filter.ts +++ b/src/template/filter/filter.ts @@ -3,16 +3,19 @@ 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[] = [] @@ -20,6 +23,6 @@ export class Filter { 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]) } } diff --git a/src/template/output.ts b/src/template/output.ts index 29e1479988..4c7da7c5c0 100644 --- a/src/template/output.ts +++ b/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 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) diff --git a/src/template/value.ts b/src/template/value.ts index ade698ed23..5fa21c6395 100644 --- a/src/template/value.ts +++ b/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) diff --git a/test/e2e/issues.ts b/test/e2e/issues.ts index 6e6917892c..0b8d9476cf 100644 --- a/test/e2e/issues.ts +++ b/test/e2e/issues.ts @@ -54,4 +54,15 @@ describe('Issues', function () { const html = engine.parseAndRenderSync(template, { condition1: true, condition2: true }) expect(html).to.equal('
Y
') }) + 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') + }) }) diff --git a/test/unit/template/filter/filter.ts b/test/unit/template/filter/filter.ts index a0f774f06b..f1b84838cd 100644 --- a/test/unit/template/filter/filter.ts +++ b/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()) diff --git a/test/unit/template/output.ts b/test/unit/template/output.ts index e55da0edd4..e19f2d8c51 100644 --- a/test/unit/template/output.ts +++ b/test/unit/template/output.ts @@ -9,9 +9,10 @@ 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 = '' }) @@ -19,25 +20,25 @@ describe('Output', 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') }) diff --git a/test/unit/template/value.ts b/test/unit/template/value.ts index 29d343b90f..fa20ad2cf8 100644 --- a/test/unit/template/value.ts +++ b/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' } })