refactor: rename toValue to toValueSync

harttle · harttle · commit 4289b4e8048f · 2022-07-10T00:24:00.000+08:00
diff --git a/src/liquid.ts b/src/liquid.ts
@@ -12,7 +12,7 @@ import { TagMap } from './template/tag/tag-map'
 import { FilterMap } from './template/filter/filter-map'
 import { LiquidOptions, normalizeDirectoryList, NormalizedFullOptions, normalize, RenderOptions } from './liquid-options'
 import { FilterImplOptions } from './template/filter/filter-impl-options'
-import { toPromise, toValue } from './util/async'
+import { toPromise, toValueSync } from './util/async'
 
 export * from './util/error'
 export * from './types'
@@ -47,7 +47,7 @@ export class Liquid {
     return toPromise(this._render(tpl, scope, { ...renderOptions, sync: false }))
   }
   public renderSync (tpl: Template[], scope?: object, renderOptions?: RenderOptions): any {
-    return toValue(this._render(tpl, scope, { ...renderOptions, sync: true }))
+    return toValueSync(this._render(tpl, scope, { ...renderOptions, sync: true }))
   }
   public renderToNodeStream (tpl: Template[], scope?: object, renderOptions: RenderOptions = {}): NodeJS.ReadableStream {
     const ctx = new Context(scope, this.options, renderOptions)
@@ -62,7 +62,7 @@ export class Liquid {
     return toPromise(this._parseAndRender(html, scope, { ...renderOptions, sync: false }))
   }
   public parseAndRenderSync (html: string, scope?: object, renderOptions?: RenderOptions): any {
-    return toValue(this._parseAndRender(html, scope, { ...renderOptions, sync: true }))
+    return toValueSync(this._parseAndRender(html, scope, { ...renderOptions, sync: true }))
   }
 
   public _parsePartialFile (file: string, sync?: boolean, currentFile?: string) {
@@ -75,7 +75,7 @@ export class Liquid {
     return toPromise<Template[]>(this.parser.parseFile(file, false))
   }
   public parseFileSync (file: string): Template[] {
-    return toValue<Template[]>(this.parser.parseFile(file, true))
+    return toValueSync<Template[]>(this.parser.parseFile(file, true))
   }
   public async renderFile (file: string, ctx?: object, renderOptions?: RenderOptions) {
     const templates = await this.parseFile(file)
@@ -98,7 +98,7 @@ export class Liquid {
     return toPromise(this._evalValue(str, ctx))
   }
   public evalValueSync (str: string, ctx: Context): any {
-    return toValue(this._evalValue(str, ctx))
+    return toValueSync(this._evalValue(str, ctx))
   }
 
   public registerFilter (name: string, filter: FilterImplOptions) {
diff --git a/src/util/async.ts b/src/util/async.ts
@@ -1,23 +1,8 @@
-import { isFunction } from './underscore'
-
-type resolver = (x?: any) => any
-
-export interface Thenable<T> {
-  then (resolve: resolver, reject?: resolver): Thenable<T>;
-  catch (reject: resolver): Thenable<T>;
-}
-
-function isThenable<T> (val: any): val is Thenable<T> {
-  return val && isFunction(val.then)
-}
-
-function isAsyncIterator (val: any): val is IterableIterator<any> {
-  return val && isFunction(val.next) && isFunction(val.throw) && isFunction(val.return)
-}
+import { isPromise, isIterator } from './underscore'
 
 // convert an async iterator to a Promise
-export async function toPromise<T> (val: Generator<unknown, T, unknown> | Thenable<T> | T): Promise<T> {
-  if (!isAsyncIterator(val)) return val
+export async function toPromise<T> (val: Generator<unknown, T, unknown> | Promise<T> | T): Promise<T> {
+  if (!isIterator(val)) return val
   let value: unknown
   let done = false
   let next = 'next'
@@ -27,8 +12,8 @@ export async function toPromise<T> (val: Generator<unknown, T, unknown> | Thenab
     value = state.value
     next = 'next'
     try {
-      if (isAsyncIterator(value)) value = toPromise(value)
-      if (isThenable(value)) value = await value
+      if (isIterator(value)) value = toPromise(value)
+      if (isPromise(value)) value = await value
     } catch (err) {
       next = 'throw'
       value = err
@@ -37,9 +22,9 @@ export async function toPromise<T> (val: Generator<unknown, T, unknown> | Thenab
   return value as T
 }
 
-// convert an async iterator to a value in a synchronous maner
-export function toValue<T> (val: Generator<unknown, T, unknown> | T): T {
-  if (!isAsyncIterator(val)) return val
+// convert an async iterator to a value in a synchronous manner
+export function toValueSync<T> (val: Generator<unknown, T, unknown> | T): T {
+  if (!isIterator(val)) return val
   let value: any
   let done = false
   let next = 'next'
@@ -48,9 +33,9 @@ export function toValue<T> (val: Generator<unknown, T, unknown> | T): T {
     done = state.done
     value = state.value
     next = 'next'
-    if (isAsyncIterator(value)) {
+    if (isIterator(value)) {
       try {
-        value = toValue(value)
+        value = toValueSync(value)
       } catch (err) {
         next = 'throw'
         value = err
diff --git a/src/util/underscore.ts b/src/util/underscore.ts
@@ -14,6 +14,14 @@ export function isFunction (value: any): value is Function {
   return typeof value === 'function'
 }
 
+export function isPromise<T> (val: any): val is Promise<T> {
+  return val && isFunction(val.then)
+}
+
+export function isIterator (val: any): val is IterableIterator<any> {
+  return val && isFunction(val.next) && isFunction(val.throw) && isFunction(val.return)
+}
+
 export function escapeRegex (str: string) {
   return str.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
 }
diff --git a/test/integration/liquid/liquid.ts b/test/integration/liquid/liquid.ts
@@ -58,6 +58,33 @@ describe('Liquid', function () {
       expect(html).to.equal('FOO')
     })
   })
+  describe('#parseAndRenderSync', function () {
+    const engine = new Liquid()
+    it('should parse and render variable output', function () {
+      const html = engine.parseAndRenderSync('{{"foo"}}')
+      expect(html).to.equal('foo')
+    })
+    it('should parse and render complex output', function () {
+      const tpl = '{{ "Welcome|to]Liquid" | split: "|" | join: "("}}'
+      const html = engine.parseAndRenderSync(tpl)
+      expect(html).to.equal('Welcome(to]Liquid')
+    })
+    it('should support for-in with variable', function () {
+      const src = '{% assign total = 3 | minus: 1 %}' +
+        '{% for i in (1..total) %}{{ i }}{% endfor %}'
+      const html = engine.parseAndRenderSync(src, {})
+      return expect(html).to.equal('12')
+    })
+    it('should support `globals` render option', function () {
+      const src = '{{ foo }}'
+      const html = engine.parseAndRenderSync(src, {}, { globals: { foo: 'FOO' } })
+      return expect(html).to.equal('FOO')
+    })
+    it('should support `strictVariables` render option', function () {
+      const src = '{{ foo }}'
+      return expect(() => engine.parseAndRenderSync(src, {}, { strictVariables: true })).throw(/undefined variable/)
+    })
+  })
   describe('#express()', function () {
     const liquid = new Liquid({ root: '/root' })
     const render = liquid.express()
diff --git a/test/unit/render/expression.ts b/test/unit/render/expression.ts
@@ -2,7 +2,7 @@ import { Tokenizer } from '../../../src/parser/tokenizer'
 import { expect } from 'chai'
 import { Drop } from '../../../src/drop/drop'
 import { Context } from '../../../src/context/context'
-import { toPromise } from '../../../src/util/async'
+import { toPromise, toValueSync } from '../../../src/util/async'
 import { defaultOperators } from '../../../src/render/operator'
 import { createTrie } from '../../../src/util/operator-trie'
 
@@ -158,4 +158,21 @@ describe('Expression', function () {
       expect(await toPromise(create('obj[keys["what\'s this"]]').evaluate(ctx, false))).to.equal('FOO')
     })
   })
+
+  describe('sync', function () {
+    it('should eval literal', function () {
+      expect(toValueSync(create('2.4').evaluate(ctx, false))).to.equal(2.4)
+    })
+    it('should return false for "1==2"', () => {
+      expect(toValueSync(create('1==2').evaluate(ctx, false))).to.equal(false)
+    })
+    it('should escape quote', function () {
+      const ctx = new Context({ quote: '"' })
+      expect(toValueSync(create('"\\"" == quote').evaluate(ctx, false))).to.equal(true)
+    })
+    it('should allow nested property access', function () {
+      const ctx = new Context({ obj: { foo: 'FOO' }, keys: { "what's this": 'foo' } })
+      expect(toValueSync(create('obj[keys["what\'s this"]]').evaluate(ctx, false))).to.equal('FOO')
+    })
+  })
 })
diff --git a/test/unit/template/filter/filter.ts b/test/unit/template/filter/filter.ts
@@ -76,6 +76,6 @@ describe('filter', function () {
   it('should support key value pairs', async function () {
     filters.set('add', (a, b) => b[0] + ':' + (a + b[1]))
     const two = new NumberToken(new IdentifierToken('2', 0, 1), undefined)
-    expect(await toPromise((filters.create('add', [['num', two]]).render(3, ctx)))).to.equal('num:5')
+    expect(await toPromise(filters.create('add', [['num', two]]).render(3, ctx))).to.equal('num:5')
   })
 })
diff --git a/test/unit/util/async.ts b/test/unit/util/async.ts
@@ -1,4 +1,4 @@
-import { toPromise, toValue } from '../../../src/util/async'
+import { toPromise, toValueSync } from '../../../src/util/async'
 import { expect, use } from 'chai'
 import * as chaiAsPromised from 'chai-as-promised'
 
@@ -75,15 +75,15 @@ describe('utils/async', () => {
       expect(ret).to.equal('barfoo')
     })
   })
-  describe('#toValue()', function () {
+  describe('#toValueSync()', function () {
     it('should throw Error if dependency throws syncly', () => {
       function * foo (): Generator<Generator<never>> {
         return yield bar()
       }
       function * bar (): Generator<never> {
         throw new Error('bar')
       }
-      expect(() => toValue(foo())).to.throw('bar')
+      expect(() => toValueSync(foo())).to.throw('bar')
     })
     it('should resume yield after catch', () => {
       function * foo (): Generator<unknown, never, never> {
@@ -95,7 +95,7 @@ describe('utils/async', () => {
       function * bar (): Generator<never> {
         throw new Error('bar')
       }
-      expect(toValue(foo())).to.equal('foo')
+      expect(toValueSync(foo())).to.equal('foo')
     })
     it('should resume return after catch', () => {
       function * foo (): Generator<Generator<never>, string> {
@@ -107,7 +107,10 @@ describe('utils/async', () => {
       function * bar (): Generator<never> {
         throw new Error('bar')
       }
-      expect(toValue(foo())).to.equal('foo')
+      expect(toValueSync(foo())).to.equal('foo')
+    })
+    it('should return non iterator value as it is', () => {
+      expect(toValueSync('foo')).to.equal('foo')
     })
   })
 })

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ import { TagMap } from './template/tag/tag-map'`
`12`	`12`	`import { FilterMap } from './template/filter/filter-map'`
`13`	`13`	`import { LiquidOptions, normalizeDirectoryList, NormalizedFullOptions, normalize, RenderOptions } from './liquid-options'`
`14`	`14`	`import { FilterImplOptions } from './template/filter/filter-impl-options'`
`15`		`-import { toPromise, toValue } from './util/async'`
	`15`	`+import { toPromise, toValueSync } from './util/async'`
`16`	`16`
`17`	`17`	`export * from './util/error'`
`18`	`18`	`export * from './types'`
`@@ -47,7 +47,7 @@ export class Liquid {`
`47`	`47`	`return toPromise(this._render(tpl, scope, { ...renderOptions, sync: false }))`
`48`	`48`	`}`
`49`	`49`	`public renderSync (tpl: Template[], scope?: object, renderOptions?: RenderOptions): any {`
`50`		`- return toValue(this._render(tpl, scope, { ...renderOptions, sync: true }))`
	`50`	`+ return toValueSync(this._render(tpl, scope, { ...renderOptions, sync: true }))`
`51`	`51`	`}`
`52`	`52`	`public renderToNodeStream (tpl: Template[], scope?: object, renderOptions: RenderOptions = {}): NodeJS.ReadableStream {`
`53`	`53`	`const ctx = new Context(scope, this.options, renderOptions)`
`@@ -62,7 +62,7 @@ export class Liquid {`
`62`	`62`	`return toPromise(this._parseAndRender(html, scope, { ...renderOptions, sync: false }))`
`63`	`63`	`}`
`64`	`64`	`public parseAndRenderSync (html: string, scope?: object, renderOptions?: RenderOptions): any {`
`65`		`- return toValue(this._parseAndRender(html, scope, { ...renderOptions, sync: true }))`
	`65`	`+ return toValueSync(this._parseAndRender(html, scope, { ...renderOptions, sync: true }))`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`public _parsePartialFile (file: string, sync?: boolean, currentFile?: string) {`
`@@ -75,7 +75,7 @@ export class Liquid {`
`75`	`75`	`return toPromise<Template[]>(this.parser.parseFile(file, false))`
`76`	`76`	`}`
`77`	`77`	`public parseFileSync (file: string): Template[] {`
`78`		`- return toValue<Template[]>(this.parser.parseFile(file, true))`
	`78`	`+ return toValueSync<Template[]>(this.parser.parseFile(file, true))`
`79`	`79`	`}`
`80`	`80`	`public async renderFile (file: string, ctx?: object, renderOptions?: RenderOptions) {`
`81`	`81`	`const templates = await this.parseFile(file)`
`@@ -98,7 +98,7 @@ export class Liquid {`
`98`	`98`	`return toPromise(this._evalValue(str, ctx))`
`99`	`99`	`}`
`100`	`100`	`public evalValueSync (str: string, ctx: Context): any {`
`101`		`- return toValue(this._evalValue(str, ctx))`
	`101`	`+ return toValueSync(this._evalValue(str, ctx))`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`public registerFilter (name: string, filter: FilterImplOptions) {`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,14 @@ export function isFunction (value: any): value is Function {`
`14`	`14`	`return typeof value === 'function'`
`15`	`15`	`}`
`16`	`16`
	`17`	`+export function isPromise<T> (val: any): val is Promise<T> {`
	`18`	`+ return val && isFunction(val.then)`
	`19`	`+}`
	`20`	`+`
	`21`	`+export function isIterator (val: any): val is IterableIterator<any> {`
	`22`	`+ return val && isFunction(val.next) && isFunction(val.throw) && isFunction(val.return)`
	`23`	`+}`
	`24`	`+`
`17`	`25`	`export function escapeRegex (str: string) {`
`18`	`26`	`return str.replace(/[-/\\^$*+?.()\|[\]{}]/g, '\\$&')`
`19`	`27`	`}`