refactor: remove unused lexical regexps

src/liquid-options.ts

@@ -33,7 +33,7 @@ export interface LiquidOptions {
   greedy?: boolean
 }
 
-export interface NormalizedOptions extends LiquidOptions {
+interface NormalizedOptions extends LiquidOptions {
   root?: string[]
 }
 

src/parser/lexical.ts

@@ -5,7 +5,6 @@ export const quoted = new RegExp(`${singleQuoted.source}|${doubleQuoted.source}`
 export const quoteBalanced = new RegExp(`(?:${quoted.source}|[^'"])*`)
 
 // basic types
-export const integer = /-?\d+/
 export const number = /[+-]?(?:\d+\.?\d*|\.?\d+)/
 export const bool = /true|false/
 
@@ -28,20 +27,10 @@ export const hashCapture = new RegExp(`(${identifier.source})\\s*:\\s*(${value.s
 
 // full match
 export const tagLine = new RegExp(`^\\s*(${identifier.source})\\s*([\\s\\S]*?)\\s*$`)
-export const literalLine = new RegExp(`^${literal.source}$`, 'i')
-export const variableLine = new RegExp(`^${variable.source}$`)
 export const numberLine = new RegExp(`^${number.source}$`)
 export const boolLine = new RegExp(`^${bool.source}$`, 'i')
 export const quotedLine = new RegExp(`^${quoted.source}$`)
 export const rangeLine = new RegExp(`^${rangeCapture.source}$`)
-export const integerLine = new RegExp(`^${integer.source}$`)
-
-// filter related
-export const valueDeclaration = new RegExp(`(?:${identifier.source}\\s*:\\s*)?${value.source}`)
-export const valueList = new RegExp(`${valueDeclaration.source}(\\s*,\\s*${valueDeclaration.source})*`)
-export const filter = new RegExp(`${identifier.source}(?:\\s*:\\s*${valueList.source})?`, 'g')
-export const filterCapture = new RegExp(`(${identifier.source})(?:\\s*:\\s*(${valueList.source}))?`)
-export const filterLine = new RegExp(`^${filterCapture.source}$`)
 
 export const operators = [
   /\s+or\s+/,
@@ -49,38 +38,6 @@ export const operators = [
   /==|!=|<=|>=|<|>|\s+contains\s+/
 ]
 
-export function isInteger (str: string) {
-  return integerLine.test(str)
-}
-
-export function isLiteral (str: string) {
-  return literalLine.test(str)
-}
-
 export function isRange (str: string) {
   return rangeLine.test(str)
 }
-
-export function isVariable (str: string) {
-  return variableLine.test(str)
-}
-
-export function matchValue (str: string) {
-  return value.exec(str)
-}
-
-export function parseLiteral (str: string) {
-  let res = str.match(numberLine)
-  if (res) {
-    return Number(str)
-  }
-  res = str.match(boolLine)
-  if (res) {
-    return str.toLowerCase() === 'true'
-  }
-  res = str.match(quotedLine)
-  if (res) {
-    return str.slice(1, -1)
-  }
-  throw new TypeError(`cannot parse '${str}' as literal`)
-}

src/render/syntax.ts

@@ -1,7 +1,7 @@
 import * as lexical from '../parser/lexical'
 import assert from '../util/assert'
 import Scope from 'src/scope/scope'
-import { range } from 'src/util/underscore'
+import { range, last } from 'src/util/underscore'
 
 const operators = {
   '==': (l: any, r: any) => l === r,
@@ -46,15 +46,12 @@ export function evalExp (exp: string, scope: Scope): any {
 export function evalValue (str: string, scope: Scope) {
   if (!str) return null
   str = str.trim()
-  if (!str) return undefined
 
-  if (lexical.isLiteral(str)) {
-    return lexical.parseLiteral(str)
-  }
-  if (lexical.isVariable(str)) {
-    return scope.get(str)
-  }
-  throw new TypeError(`cannot eval '${str}' as value`)
+  if (str === 'true') return true
+  if (str === 'false') return false
+  if (!isNaN(Number(str))) return Number(str)
+  if ((str[0] === '"' || str[0] === "'") && str[0] === last(str)) return str.slice(1, -1)
+  return scope.get(str)
 }
 
 export function isTruthy (val: any): boolean {

src/scope/scope.ts

@@ -1,6 +1,5 @@
 import * as _ from '../util/underscore'
 import { __assign } from 'tslib'
-import * as lexical from '../parser/lexical'
 import assert from '../util/assert'
 import { NormalizedFullOptions, applyDefault } from '../liquid-options'
 import BlockMode from './block-mode'
@@ -115,7 +114,7 @@ export default class Scope {
             j = matchRightBracket(str, i + 1)
             assert(j !== -1, `unbalanced []: ${str}`)
             name = str.slice(i + 1, j)
-            if (!lexical.isInteger(name)) { // foo[bar] vs. foo[1]
+            if (!/^[+-]?\d+$/.test(name)) { // foo[bar] vs. foo[1]
               name = String(this.get(name))
             }
             push()

src/template/tag/block-tag.ts

@@ -1,45 +0,0 @@
-import { create, stringify } from 'src/util/underscore'
-import assert from 'src/util/assert'
-import Scope from 'src/scope/scope'
-import ITagImpl from './itag-impl'
-import ITagImplOptions from './itag-impl-options'
-import Liquid from 'src/liquid'
-import Hash from './hash'
-import Template from 'src/template/template'
-import ITemplate from 'src/template/itemplate'
-import TagToken from 'src/parser/tag-token'
-import Token from 'src/parser/token'
-
-export default class Tag extends Template<TagToken> implements ITemplate {
-  name: string
-  private impl: ITagImpl
-  static impls: { [key: string]: ITagImplOptions } = {}
-
-  constructor (token: TagToken, tokens: Token[], liquid: Liquid) {
-    super(token)
-    this.name = token.name
-
-    const impl = Tag.impls[token.name]
-    assert(impl, `tag ${token.name} not found`)
-    this.impl = create<ITagImplOptions, ITagImpl>(impl)
-    this.impl.liquid = liquid
-    if (this.impl.parse) {
-      this.impl.parse(token, tokens)
-    }
-  }
-  async render (scope: Scope) {
-    const hash = new Hash(this.token.args, scope)
-    const impl = this.impl
-    if (typeof impl.render !== 'function') {
-      return ''
-    }
-    const html = await impl.render(scope, hash)
-    return stringify(html)
-  }
-  static register (name: string, tag: ITagImplOptions) {
-    Tag.impls[name] = tag
-  }
-  static clear () {
-    Tag.impls = {}
-  }
-}