haparanda 0.0.1 → 0.0.2

data/lib/haparanda/handlebars_processor.rb

@@ -10,135 +10,285 @@ module Haparanda
       end
     end
 
-    class Input
-      def initialize(value)
-        @stack = [value]
-      end
+    module ValueDigger
+      private
 
-      def dig(*keys)
-        index = -1
-        value = @stack[index]
+      def dig_value(value, keys)
         keys.each do |key|
-          if key == :".."
-            index -= 1
-            value = @stack[index]
-          end
-          next if %i[.. . this].include? key
+          next if [DOT, THIS].include? key
 
           value = case value
                   when Hash
-                    value[key]
+                    value.fetch(key) do |k|
+                      value.fetch(k.to_s, nil)
+                    end
+                  when Array
+                    value[key.to_s.to_i]
                   when nil
                     nil
                   else
-                    value.send key
+                    value.send key if value.respond_to? key
                   end
         end
 
         value
       end
+    end
+
+    class Input
+      include ValueDigger
+
+      def initialize(value, parent = nil)
+        @value = value
+        @parent = parent
+      end
+
+      attr_reader :value
+
+      def dig(*keys)
+        return @parent&.dig(*keys[1..]) if keys.first == UP
+
+        dig_value(@value, keys)
+      end
+
+      def [](key)
+        dig(key)
+      end
+    end
+
+    class InputStack
+      def initialize(value, compat: false)
+        input = Input.new(value)
+        @stack = [input]
+        @compat = compat
+      end
+
+      def dig(*keys)
+        if @compat
+          @stack.reverse_each do |item|
+            return item.dig(*keys) if item[keys.first]
+          end
+          nil
+        else
+          top&.dig(*keys)
+        end
+      end
+
+      def [](key)
+        dig(key)
+      end
 
       def with_new_context(value, &block)
-        # TODO: This prevents a SystemStackError. Make this unnecessary, for
-        # example by moving the stacking behavior out of the Input class.
-        if self == value
+        # TODO: Remove the self == value case
+        if self == value || value == top.value
           block.call
         else
-          @stack.push value
+          @stack.push Input.new(value, top)
           result = block.call
           @stack.pop
           result
         end
       end
 
-      def to_s
-        @stack.last.to_s
-      end
-
-      def this
-        self
-      end
-
-      def respond_to_missing?(_method_name)
-        true
+      def with_isolated_context(value, &block)
+        input = value.is_a?(Input) ? value : Input.new(value)
+        @stack.push input
+        result = block.call
+        @stack.pop
+        result
       end
 
-      def method_missing(method_name, *_args)
-        dig(method_name)
+      def top
+        @stack.last
       end
     end
 
     class Data
       def initialize(data = {})
-        @data = data
+        @stack = [data]
       end
 
       def data(*keys)
-        @data.dig(*keys)
+        @stack.reverse_each do |item|
+          case keys.first
+          when UP
+            keys.shift
+            next
+          when DOT
+            keys.shift
+          end
+          return item.dig(*keys)
+        end
+      end
+
+      def [](key)
+        top[key]
+      end
+
+      def key?(key)
+        top.key? key
       end
 
       def set_data(key, value)
-        @data[key] = value
+        top[key] = value
       end
 
-      def with_new_data(&block)
-        data = @data.clone
+      def with_new_data(new_data = nil, &block)
+        data = top.clone
+        data.merge! new_data if new_data
+        @stack.push data
         result = block.call
-        @data = data
+        @stack.pop
         result
       end
 
-      def respond_to_missing?(method_name)
-        @data.key? method_name
-      end
+      private
 
-      def method_missing(method_name, *_args)
-        @data[method_name] if @data.key? method_name
+      def top
+        @stack.last
       end
     end
 
     class NoData
       def set_data(key, value); end
 
-      def with_new_data(&block)
+      def key?(_key)
+        false
+      end
+
+      def with_new_data(_new_data = nil, &block)
         block.call
       end
     end
 
     class Options
-      def initialize(fn:, inverse:, hash:, data:)
+      def initialize(fn:, inverse:, hash:, data:, block_params:, name: nil)
         @fn = fn
         @inverse = inverse
+        @name = name
         @hash = hash
         @data = data
+        @block_params = block_params
       end
 
-      attr_reader :hash, :data
+      attr_reader :name, :hash, :data, :block_params
 
-      def fn(arg = nil)
-        @fn&.call(arg)
+      def fn(arg = nil, options = {})
+        @fn&.call(arg, options)
       end
 
       def inverse(arg = nil)
         @inverse&.call(arg)
       end
+
+      def lookup_property(item, index)
+        case item
+        when Input, Hash
+          item[index.to_sym]
+        when Array
+          item[index]
+        when nil
+          nil
+        else
+          raise NotImplementedError
+        end
+      end
+    end
+
+    class HelperContext
+      def initialize(input_stack)
+        @input_stack = input_stack
+      end
+
+      def this
+        @input_stack.top.value
+      end
+    end
+
+    class BlockParameterList
+      include ValueDigger
+
+      def initialize
+        @values = {}
+      end
+
+      def with_new_values(&block)
+        values = @values.clone
+        result = block.call
+        @values = values
+        result
+      end
+
+      def key?(key)
+        @values.key? key
+      end
+
+      def set_value(key, value)
+        @values[key] = value
+      end
+
+      def value(key, *rest)
+        dig_value(@values.fetch(key), rest)
+      end
+    end
+
+    module Utils
+      module_function
+
+      def escape(str)
+        return str if str.is_a? SafeString
+
+        str.gsub(/[&<>"'`=]/) do |chr|
+          ESCAPE[chr]
+        end
+      end
+    end
+
+    class Segment
+      def initialize(name)
+        @name = name
+      end
+
+      def to_s
+        @name
+      end
     end
 
-    def initialize(input, custom_helpers = nil, data: {})
+    UP = Segment.new("..")
+    DOT = Segment.new(".")
+    THIS = Segment.new("THIS")
+
+    SEGMENT_MAP = {
+      ".": DOT,
+      this: THIS,
+      "..": UP
+    }.freeze
+
+    def initialize(input, helpers: {}, partials: {}, data: {}, log: nil,
+                   compat: false, explicit_partial_context: false, no_escape: false)
       super()
 
       self.require_empty = false
 
-      @input = Input.new(input)
+      @input_stack = InputStack.new(input, compat: compat)
       @data = data ? Data.new(data) : NoData.new
+      @helper_context = HelperContext.new(@input_stack)
+      @block_parameter_list = BlockParameterList.new
+
+      @data.set_data(:root, @input_stack.top) unless @data.key?(:root)
 
-      custom_helpers ||= {}
       @helpers = {
         if: method(:handle_if),
         unless: method(:handle_unless),
         with: method(:handle_with),
-        each: method(:handle_each)
-      }.merge(custom_helpers)
+        each: method(:handle_each),
+        log: method(:handle_log),
+        lookup: method(:handle_lookup)
+      }.merge(helpers)
+      @partials = Data.new(partials.transform_keys(&:to_s))
+      @log = log || method(:default_log)
+      @explicit_partial_context = explicit_partial_context
+      @escape_values = !no_escape
     end
 
     def apply(expr)
@@ -148,32 +298,125 @@ module Haparanda
 
     def process_root(expr)
       _, statements = expr
-      process(statements)
+      if statements
+        process(statements)
+      else
+        s(:result, nil)
+      end
     end
 
     def process_mustache(expr)
       _, path, params, hash, escaped, _strip = expr
       params = process(params)[1]
-      hash = process(hash)[1] if hash
-      data, elements = path_segments process(path)
-      value = lookup_path(data, elements)
-      value = execute_in_context(value, params, hash: hash) if value.respond_to? :call
+      hash = extract_hash(hash)
+      value, name = lookup_value(path)
+
+      if value.nil?
+        value = @helpers[:helperMissing]
+        raise "Missing helper: \"#{name}\"" if value.nil? && !params.empty?
+      end
+
+      if value.respond_to? :call
+        value = execute_in_context(value, params, name: name, hash: hash)
+      end
+
       value = value.to_s
-      value = escape(value) if escaped
+      value = Utils.escape(value) if @escape_values && escaped
       s(:result, value)
     end
 
     def process_block(expr)
-      _, name, params, hash, program, inverse_chain, = expr
-      hash = process(hash)[1] if hash
+      _, path, params, hash, program, inverse_chain, = expr
+      hash = extract_hash hash
       else_program = inverse_chain.sexp_body[1] if inverse_chain
       arguments = process(params)[1]
 
-      path = process(name)
-      data, elements = path_segments(path)
-      value = lookup_path(data, elements)
+      value, name = lookup_value(path)
+
+      evaluate_program_with_value(value, arguments, program, else_program, hash, name: name)
+    end
+
+    def process_partial(expr)
+      _, name, context, hash, indent, = expr
+
+      values = process(context)[1]
+      if values.length > 1
+        raise "Unsupported number of partial arguments: #{values.length} - #{expr.line}"
+      end
+
+      value = values.first
+
+      partial = lookup_partial(name)
+      partial_f = if partial.is_a?(Sexp)
+                    lambda do |value|
+                      @input_stack.with_isolated_context(value) { process(partial) }
+                    end
+                  else
+                    partial
+                  end
+
+      hash = extract_hash hash
+      result = with_block_params(hash.keys, hash.values) do
+        value ||= @input_stack.top unless @explicit_partial_context
+        partial_f.call(value)
+      end
+
+      apply_indent result, indent
+
+      result
+    end
+
+    # rubocop:todo Metrics/MethodLength
+    # rubocop:todo Metrics/AbcSize
+    def process_partial_block(expr)
+      _, name, context, _hash, partial_block = expr
+
+      values = process(context)[1]
+      value = values.first
+
+      current_partial_block = @data.data(:"partial-block")
+
+      @data.with_new_data do
+        data = @data
+        processor = self
+        partial_block_wrapper = lambda do |value|
+          data.with_new_data do
+            data.set_data(:"partial-block", current_partial_block)
+            @input_stack.with_isolated_context(value) { processor.process(partial_block) }
+          end
+        end
+
+        @data.set_data(:"partial-block", partial_block_wrapper)
+
+        partial_block&.sexp_body&.each do |sexp|
+          process(sexp) if sexp.sexp_type == :directive_block
+        end
+
+        partial = lookup_partial(name, raise_error: false)
+        partial ||= partial_block_wrapper
+        partial_f = if partial.is_a?(Sexp)
+                      lambda do |value|
+                        @input_stack.with_isolated_context(value) { process(partial) }
+                      end
+                    else
+                      partial
+                    end
+
+        value ||= @input_stack.top unless @explicit_partial_context
+        partial_f.call(value)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def process_directive_block(expr)
+      _, name, params, _hash, program, _inverse_chain, = expr
+      name = name.dig(2, 1)
+      raise "Only 'inline' is supported, got #{name}" unless name == "inline"
 
-      evaluate_program_with_value(value, arguments, program, else_program, hash)
+      args = process(params)[1]
+      partial_name = args[0]
+      @partials.set_data(partial_name, program)
     end
 
     def process_statements(expr)
@@ -194,8 +437,16 @@ module Haparanda
 
     def process_path(expr)
       _, data, *segments = expr
-      segments = segments.each_slice(2).map { |elem, _sep| elem[1].to_sym }
-      s(:segments, data, segments)
+      path_segments = []
+      name_parts = segments.each_slice(2).flat_map do |elem, sep|
+        sep = sep&.at(1)
+        part = elem[1].to_sym
+        part = SEGMENT_MAP.fetch(part, part) unless elem[2]
+        path_segments << part
+        [part, sep]
+      end
+      name = name_parts.join
+      s(:segments, data, name, path_segments)
     end
 
     def process_exprs(expr)
@@ -213,116 +464,298 @@ module Haparanda
       s(:hash, hash)
     end
 
+    def process_sub_expression(expr)
+      _, path, params, hash = expr
+      value, name = lookup_value(path)
+
+      arguments = process(params)[1]
+      hash = extract_hash hash
+
+      result = execute_in_context(value, arguments, hash: hash, name: name)
+      s(:result, result)
+    end
+
+    LOG_LEVELS = %w[debug info warn error].freeze
+
     private
 
-    def evaluate_program_with_value(value, arguments, program, else_program, hash)
-      fn = make_contextual_lambda(program)
+    # rubocop:todo Metrics/PerceivedComplexity
+    # rubocop:todo Metrics/MethodLength
+    # rubocop:todo Metrics/AbcSize
+    # rubocop:todo Metrics/CyclomaticComplexity
+    def evaluate_program_with_value(value, arguments, program, else_program, hash,
+                                    name: nil)
+      block_params = extract_block_param_names(program)
+      fn = make_contextual_lambda(program, block_params)
       inverse = make_contextual_lambda(else_program)
 
-      if value.respond_to? :call
-        value = execute_in_context(value, arguments, fn: fn, inverse: inverse, hash: hash)
+      if value.nil? && (hash.any? || arguments.any?)
+        value = @helpers[:helperMissing] or raise "Missing helper: \"#{name}\""
+      end
+
+      while value.respond_to?(:call)
+        value = execute_in_context(value, arguments, name: name,
+                                                     fn: fn, inverse: inverse, hash: hash,
+                                                     block_params: block_params&.count)
+      end
+      return s(:result, value.to_s) if arguments.any?
+
+      if (helper = @helpers[:blockHelperMissing])
+        value = execute_in_context(helper, [value], name: name,
+                                                    fn: fn, inverse: inverse, hash: hash,
+                                                    block_params: block_params&.count)
         return s(:result, value.to_s)
       end
 
-      case value
-      when Array
-        return s(:result, inverse.call(@input)) if value.empty?
+      result = case value
+               when Array
+                 if value.empty?
+                   inverse.call(@input_stack)
+                 else
+                   parts = value.each_with_index.map do |elem, index|
+                     @data.set_data(:index, index)
+                     fn.call(elem)
+                   end
+                   parts.join
+                 end
+               when true
+                 fn.call(@input_stack)
+               when false, nil
+                 inverse.call(@input_stack)
+               else
+                 fn.call(value)
+               end
+
+      s(:result, result)
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
 
-        parts = value.each_with_index.map do |elem, index|
-          @data.set_data(:index, index)
-          fn.call(elem)
-        end
-        s(:result, parts.join)
+    def extract_block_param_names(program)
+      return [] unless program&.sexp_type == :program
+
+      if (params_definition = program[1])
+        params_definition.sexp_body.map { _1[1].to_sym }
       else
-        result = value ? fn.call(value) : inverse.call(@input)
-        s(:result, result)
+        []
       end
     end
 
-    def make_contextual_lambda(program)
+    def extract_hash(expr)
+      if expr
+        process(expr)[1]
+      else
+        {}
+      end
+    end
+
+    def make_contextual_lambda(program, block_param_names = [])
       if program
-        ->(item) { @input.with_new_context(item) { apply(program) } }
+        if block_param_names.any?
+          lambda { |item, options = {}|
+            with_new_context(item, options[:data]) do
+              with_block_params(block_param_names, options[:block_params]) do
+                apply(program)
+              end
+            end
+          }
+        else
+          lambda { |item, options = {}|
+            with_new_context(item, options[:data]) { apply(program) }
+          }
+        end
       else
         ->(_item) { "" }
       end
     end
 
+    def with_new_context(item, data, &)
+      @data.with_new_data(data) do
+        @partials.with_new_data do
+          @input_stack.with_new_context(item, &)
+        end
+      end
+    end
+
+    def with_block_params(block_param_names, block_param_values, &block)
+      @block_parameter_list.with_new_values do
+        if block_param_values
+          block_param_names.zip(block_param_values) do |name, value|
+            @block_parameter_list.set_value(name, value)
+          end
+        end
+        block.call
+      end
+    end
+
     def evaluate_expr(expr)
-      path = process(expr)
-      case path.sexp_type
-      when :segments
-        data, elements = path.sexp_body
-        value = lookup_path(data, elements)
-        value = execute_in_context(value) if value.respond_to? :call
+      case expr.sexp_type
+      when :path
+        value, name = lookup_value(expr)
+        value = execute_in_context(value, name: name) if value.respond_to? :call
         value
       when :undefined, :null
         nil
       else
-        path[1]
+        process(expr)[1]
       end
     end
 
+    def lookup_value(expr)
+      path = process(expr)
+      data, name, elements = path_segments(path)
+      value = if data
+                @data.data(*elements)
+              elsif @block_parameter_list.key?(elements.first)
+                @block_parameter_list.value(*elements)
+              elsif elements.one? && @helpers.key?(elements.first)
+                @helpers[elements.first]
+              else
+                @input_stack.dig(*elements)
+              end
+      return value, name
+    end
+
+    # TODO: Remove boolean parameter code smell
+    def lookup_partial(expr, raise_error: true)
+      path = process(expr)
+      data, name, elements = path_segments(path)
+
+      result = if data
+                 @data.data(*elements)
+               else
+                 @partials.data(name)
+               end
+
+      raise KeyError, "The partial \"#{name}\" could not be found" if !result && raise_error
+
+      result
+    end
+
     def path_segments(path)
       case path.sexp_type
       when :segments
-        data, elements = path.sexp_body
+        data, name, elements = path.sexp_body
       when :undefined, :null
         elements = [path.sexp_type]
+        name = elements.join
       else
         elements = [path[1]]
+        name = elements.join
       end
-      return data, elements
+      return data, name, elements
     end
 
-    def lookup_path(data, elements)
-      if data
-        @data.data(*elements)
-      elsif elements.count == 1 && @helpers.key?(elements.first)
-        @helpers[elements.first]
-      else
-        @input.dig(*elements)
+    def execute_in_context(callable, params = [], name:,
+                           fn: nil, inverse: nil, block_params: 0, hash: nil)
+      arity = callable.arity
+      num_params = params.count
+      arity = num_params + 2 if arity < 0
+      raise_arity_error(arity, name, is_block: !fn.nil?) if arity > num_params + 2
+
+      params = params.take(arity) if num_params > arity
+
+      if arity > num_params
+        options = Options.new(name: name,
+                              fn: fn, inverse: inverse,
+                              block_params: block_params, hash: hash,
+                              data: @data)
+        params.push options
       end
+      params.unshift @helper_context.this if arity > num_params + 1
+      @helper_context.instance_exec(*params, &callable)
     end
 
-    def execute_in_context(callable, params = [], fn: nil, inverse: nil, hash: nil)
-      num_params = callable.arity
-      raise NotImplementedError if num_params < 0
-
-      args = [*params, Options.new(fn: fn, inverse: inverse, hash: hash, data: @data)]
-      args = args.take(num_params)
-      @input.instance_exec(*args, &callable)
+    def raise_arity_error(arity, name, is_block: false)
+      expected = arity - 2
+      identifier = is_block ? "##{name}" : name
+      raise ArgumentError,
+            "Expected #{expected} argument#{'s' if expected > 1} for #{identifier}"
     end
 
-    def handle_if(value, options)
+    def handle_if(context, *values, options)
+      raise ArgumentError, "#if requires exactly one argument" unless values.size == 1
+
+      value = values.first
       if value
-        options.fn(@input)
+        options.fn(context)
       else
-        options.inverse(@input)
+        options.inverse(context)
       end
     end
 
-    def handle_unless(value, options)
-      options.fn(@input) unless value
+    def handle_unless(context, *values, options)
+      raise ArgumentError, "#unless requires exactly one argument" unless values.size == 1
+
+      value = values.first
+      options.fn(context) unless value
     end
 
-    def handle_with(value, options)
+    def handle_with(_context, *values, options)
+      raise ArgumentError, "#with requires exactly one argument" unless values.size == 1
+
+      value = values.first
       if value
-        options.fn(value)
+        options.fn(value, block_params: [value])
       else
         options.inverse(value)
       end
     end
 
-    def handle_each(value, options)
+    def handle_each(_context, value, options)
       return unless value
 
-      value = value.values if value.is_a? Hash
-      @data.with_new_data do
-        value.each_with_index.map do |item, index|
-          @data.set_data(:index, index)
-          options.fn(item)
-        end.join
+      last = value.respond_to?(:length) ? value.length - 1 : -1
+      data = options.data
+      data.with_new_data do
+        unless value.is_a? Hash
+          value = value.each_with_index.lazy.map { |item, index| [index, item] }
+        end
+        items = value.each_with_index.map do |(key, item), index|
+          data.set_data(:key, key)
+          data.set_data(:index, index)
+          data.set_data(:first, index == 0)
+          data.set_data(:last, index == last)
+          options.fn(item, block_params: [item, index])
+        end
+        items.to_a.join
+      end
+    end
+
+    def handle_log(_context, *values, options)
+      level = options.hash[:level] || @data.data(:level) || 1
+      @log.call(level, *values)
+      nil
+    end
+
+    def handle_lookup(_context, item, index, options)
+      options.lookup_property(item, index)
+    end
+
+    def apply_indent(result, indent)
+      if indent && (indent_text = indent[1])
+        str = result[1].lines.map { |line| "#{indent_text}#{line}" }
+        result[1] = str
+      end
+    end
+
+    def default_log(level, *values)
+      case level
+      when String
+        level = Integer(level, exception: false) || LOG_LEVELS.index(level.downcase)
       end
+      level ||= Logger::UNKNOWN
+      logger.add(level, values.join(" "))
+    end
+
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+
+    def raise_helper_missing(name)
+      raise "Missing helper: \"#{name}\""
     end
 
     ESCAPE = {
@@ -335,13 +768,5 @@ module Haparanda
       "=" => "&#x3D;"
     }.freeze
     private_constant :ESCAPE
-
-    def escape(str)
-      return str if str.is_a? SafeString
-
-      str.gsub(/[&<>"'`=]/) do |chr|
-        ESCAPE[chr]
-      end
-    end
   end
 end