liquid-node

Liquid = require "../liquid" { _ } = require "underscore" Q = require "q" module.exports = class Context constructor: (environments = {}, outerScope = {}, registers = {}, rethrowErrors = false) -> @environments = _.flatten [environments] @scopes = [outerScope or {}] @registers = registers @errors = [] @rethrowErrors = rethrowErrors @strainer = Liquid.Strainer.create(@) @squashInstanceAssignsWithEnvironments() # Adds filters to this context. # # Note that this does not register the filters with the main # Template object. see <tt>Template.register_filter</tt> # for that addFilters: (filters) -> filters = _([filters]).chain().flatten().compact().value() filters.forEach (filter) => unless filter instanceof Object throw new Error("Expected Object but got: #{typeof(filter)}") _.extend @strainer, filter handleError: (e) -> @errors.push e throw e if @rethrowErrors if e instanceof Liquid.SyntaxError "Liquid syntax error: #{e.message}" else "Liquid error: #{e.message}" invoke: (method, args...) -> if @strainer[method]? f = @strainer[method] f.apply(@strainer, args) else args?[0] push: (newScope = {}) -> Liquid.log "SCOPE PUSH" @scopes.unshift newScope throw new Error("Nesting too deep") if @scopes.length > 100 merge: (newScope = {}) -> _(@scopes[0]).extend(newScope) pop: -> Liquid.log "SCOPE POP" throw new Error("ContextError") if @scopes.length <= 1 @scopes.shift() lastScope: -> @scopes[@scopes.length-1] # Pushes a new local scope on the stack, pops it at the end of the block # # Example: # context.stack do # context['var'] = 'hi' # end # # context['var] #=> nil stack: (newScope = {}, f) -> popLater = false try if arguments.length < 2 f = newScope newScope = {} @push(newScope) result = f() if Q.isPromise result popLater = true result.nodeify => @pop() result finally @pop() unless popLater clearInstanceAssigns: -> @scopes[0] = {} # Only allow String, Numeric, Hash, Array, Proc, Boolean # or <tt>Liquid::Drop</tt> set: (key, value) -> Liquid.log "[SET] %s %j", key, value @scopes[0][key] = value get: (key) -> value = @resolve(key) Liquid.log "[GET] %s %j", key, value value hasKey: (key) -> !!@resolve(key) # PRIVATE API @Literals = 'null': null 'nil': null '': null 'true': true 'false': false 'empty': (v) -> not (v?.length > 0) # false for non-collections 'blank': (v) -> !v or v.toString().length is 0 # Look up variable, either resolve directly after considering the name. # We can directly handle Strings, digits, floats and booleans (true,false). # If no match is made we lookup the variable in the current scope and # later move up to the parent blocks to see if we can resolve # the variable somewhere up the tree. # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions # # Example: # products == empty #=> products.empty? resolve: (key) -> if Liquid.Context.Literals.hasOwnProperty key Liquid.Context.Literals[key] else if match = /^'(.*)'$/.exec(key) # Single quoted strings match[1] else if match = /^"(.*)"$/.exec(key) # Double quoted strings match[1] else if match = /^(\d+)$/.exec(key) # Integer and floats Number(match[1]) else if match = /^$(\S+)\.\.(\S+)$$/.exec(key) # Ranges lo = Number(resolve(match[1])) hi = Number(resolve(match[2])) throw new Error "Ranges are not supported." else if match = /^(\d[\d\.]+)$/.exec(key) # Floats Number(match[1]) else @variable(key) findVariable: (key) -> scope = _(@scopes).detect (scope) -> scope.hasOwnProperty key variable = undefined scope ?= _(@environments).detect (env) => variable = @lookupAndEvaluate(env, key) variable? scope ?= _(@environments).last or _(@scopes).last variable ?= @lookupAndEvaluate(scope, key) Q.when(variable).then(@liquify.bind(@)) variable: (markup) -> Q.fcall => parts = Liquid.Helpers.scan(markup, Liquid.VariableParser) squareBracketed = /^\[(.*)\]$/ firstPart = parts.shift() if match = squareBracketed.exec(firstPart) firstPart = match[1] object = @findVariable(firstPart) return object if parts.length is 0 mapper = (part, object) => return Q.when(object) unless object? Q.when(object).then(@liquify.bind(@)).then (object) => return object unless object? bracketMatch = squareBracketed.exec part part = @resolve(bracketMatch[1]) if bracketMatch Q.when(part).then (part) => isArrayAccess = (_.isArray(object) and _.isNumber(part)) isObjectAccess = (_.isObject(object) and (part of object)) isSpecialAccess = ( !bracketMatch and object and (_.isArray(object) or _.isString(object)) and ["size", "first", "last"].indexOf(part) >= 0 ) if isArrayAccess or isObjectAccess # If object is a hash- or array-like object we look for the # presence of the key and if its available we return it Q.when(@lookupAndEvaluate(object, part)).then(@liquify.bind(@)) else if isSpecialAccess # Some special cases. If the part wasn't in square brackets # and no key with the same name was found we interpret # following calls as commands and call them on the # current object switch part when "size" @liquify(object.length) when "first" @liquify(object[0]) when "last" @liquify(object[object.length-1]) else throw new Error "Unknown special accessor: #{part}" # The iterator walks through the parsed path step # by step and waits for promises to be fulfilled. iterator = (object, index) -> if index < parts.length mapper(parts[index], object).then (object) -> iterator(object, index + 1) else Q.when(object) iterator(object, 0).then null, (err) -> throw new Error "Couldn't walk variable: #{markup}: #{err}" lookupAndEvaluate: (obj, key) -> value = obj[key] if typeof value is 'function' obj[key] = value.call obj, @ # cache result else value squashInstanceAssignsWithEnvironments: -> lastScope = @lastScope() _(lastScope).chain().keys().forEach (key) => _(@environments).detect (env) => if env.hasOwnProperty key lastScope[key] = @lookupAndEvaluate(env, key) true liquify: (object) -> Q.when(object).then (object) => unless object? return object else if typeof object.toLiquid is "function" object = object.toLiquid() else if typeof object is "object" true # throw new Error "Complex object #{JSON.stringify(object)} would leak into template." object.context = @ if object instanceof Liquid.Drop object