haparanda 0.0.1

data/lib/haparanda/handlebars_parser.y

@@ -0,0 +1,358 @@
+class Haparanda::HandlebarsParser
+rule
+start root
+
+# %ebnf
+
+# %%
+
+# Based on src/handlebars.yy in handlebars-parser. Some extra rules were added
+# because racc does not support certain things that jison supports.
+#
+# For example, the '*' to signify zero or more items. Rules that need this were
+# generaly split into 'none | items', plus a new rule defining items as 'item |
+# items item'.
+#
+# Similarly, an extra rule is needed to replace '?' signifyling zero or one of
+# an item.
+#
+# src/handlebars.yy in handlebars-parser is covered by the ICS license. See README.md
+# for details.
+
+root
+  : program { result = s(:root, val[0]) }
+  ;
+
+program
+  : none
+  | statements
+  ;
+
+# Extra rule needed for racc to parse list of one or more statements
+statements
+  : statement { result = s(:statements, val[0]) }
+  | statements statement { result << val[1] }
+  ;
+
+statement
+  : mustache
+  | block
+  | rawBlock
+  | partial
+  | partialBlock
+  | content
+  | COMMENT {
+    result = s(:comment, strip_comment(val[0]), strip_flags(val[0], val[0]))
+      .line(self.lexer.lineno)
+  };
+
+content:
+  CONTENT {
+    result = s(:content, val[0])
+    result.line = self.lexer.lineno
+  }
+  ;
+
+# Extra rule needed to replace content*
+contents:
+  : none {
+    result = s(:content, "")
+    result.line = self.lexer.lineno
+  }
+  | contentList
+  ;
+
+# Extra rule needed for racc to parse list of one or more contents
+contentList:
+  content
+  | contentList CONTENT {
+    result[1] += val[1]
+  }
+  ;
+
+rawBlock
+  : openRawBlock contents END_RAW_BLOCK { result = prepare_raw_block(val[0], val[1], val[2]) }
+  ;
+
+openRawBlock
+  : OPEN_RAW_BLOCK helperName exprs hash CLOSE_RAW_BLOCK {
+    result = s(:open_raw, *val[1..3], strip_flags(val[0], val[4])).line(self.lexer.lineno)
+  }
+  ;
+
+block
+  : openBlock program inverseChain closeBlock { result = prepare_block(val[0], val[1], val[2], val[3], false) }
+  | openInverse program optInverseAndProgram closeBlock {  result = prepare_block(val[0], val[1], val[2], val[3], true) }
+  ;
+
+openBlock
+  : OPEN_BLOCK helperName exprs hash blockParams CLOSE {
+    decorator, _escaped = interpret_open_token(val[0])
+    type = decorator ? :open_directive : :open
+    result = s(type, *val[1..4], strip_flags(val[0], val[5]))
+  }
+  ;
+
+openInverse
+  : OPEN_INVERSE helperName exprs hash blockParams CLOSE { result = s(:open, val[1], val[2], val[3], val[4], strip_flags(val[0], val[5])) }
+  ;
+
+openInverseChain
+  : OPEN_INVERSE_CHAIN helperName exprs hash blockParams CLOSE { result = s(:open, val[1], val[2], val[3], val[4], strip_flags(val[0], val[5])) }
+  ;
+
+# Extra rule needed for racc to parse zero or one of inverseAndProgram
+optInverseAndProgram
+  : none
+  | inverseAndProgram
+  ;
+
+inverseAndProgram
+  : INVERSE program { result = s(:inverse, nil, val[1], strip_flags(val[0], val[0]), nil) }
+  ;
+
+inverseChain
+  : none
+  | openInverseChain program inverseChain {
+    block = prepare_block(val[0], val[1], val[2], nil, false)
+    result = s(:inverse, nil, block, nil, nil)
+  }
+  | inverseAndProgram
+  ;
+
+closeBlock
+  : OPEN_ENDBLOCK helperName CLOSE { result = s(:close, val[1], strip_flags(val[0], val[2])) }
+  ;
+
+mustache
+  : OPEN expr exprs hash CLOSE { result = prepare_mustache(*val) }
+  | OPEN_UNESCAPED expr exprs hash CLOSE_UNESCAPED { result = prepare_mustache(*val) }
+  ;
+
+partial
+  : OPEN_PARTIAL expr exprs hash CLOSE {
+    result = s(:partial, val[1], val[2], val[3], strip_flags(val[0], val[4]))
+      .line(self.lexer.lineno)
+  }
+  ;
+
+partialBlock
+  : openPartialBlock program closeBlock { result = prepare_partial_block(*val) }
+  ;
+
+openPartialBlock
+  : OPEN_PARTIAL_BLOCK expr exprs hash CLOSE { result = s(:open_partial, val[1], val[2], val[3], strip_flags(val[0], val[4])) }
+  ;
+
+expr
+  : helperName
+  | sexpr
+  ;
+
+# Extra rule needed to replace all cases of expr*
+exprs:
+  : none { result = s(:exprs) }
+  | exprList
+  ;
+
+# Extra rule needed for racc to parse list of one or more exprs
+exprList
+  : expr { result = s(:exprs, val[0]) }
+  | exprList expr { result.push(val[1]) }
+  ;
+
+sexpr
+  : OPEN_SEXPR expr exprs hash CLOSE_SEXPR {
+    result = s(:sub_expression, val[1], val[2], val[3]).line self.lexer.lineno
+  };
+
+hash
+  : none
+  | hashSegments { result = result.line(self.lexer.lineno) }
+  ;
+
+# Extra rule needed for racc to parse list of one or more hash segments
+hashSegments
+  hashSegment { result = s(:hash, val[0]) }
+  | hashSegments hashSegment { result.push(val[1]) }
+  ;
+
+hashSegment
+  : KEY_ASSIGN expr { result = s(:hash_pair, val[0], val[1]).line(self.lexer.lineno) }
+  ;
+
+blockParams
+  : none
+  | OPEN_BLOCK_PARAMS idSequence CLOSE_BLOCK_PARAMS { result = s(:block_params, *val[1]) }
+  ;
+
+# Extra rule needed for racc to parse list of one or more IDs
+idSequence
+  : ID { result = [id(val[0])] }
+  | idSequence ID { result << id(val[1]) }
+  ;
+
+helperName
+  : path
+  | dataName
+  | STRING { result = s(:string, val[0]).line(self.lexer.lineno) }
+  | NUMBER { result = s(:number, process_number(val[0])).line(self.lexer.lineno) }
+  | BOOLEAN { result = s(:boolean, val[0] == "true").line(self.lexer.lineno) }
+  | UNDEFINED { result = s(:undefined).line(self.lexer.lineno) }
+  | NULL { result = s(:null).line(self.lexer.lineno) }
+  ;
+
+dataName
+  : DATA pathSegments { result = prepare_path(true, false, val[1], self.lexer.lineno) }
+  ;
+
+path
+  : sexpr SEP pathSegments {
+    # NOTE: Separator is always parsed as '/'
+    result = prepare_path(false, false, [val[0], s(:sep, "/"), *val[2]], self.lexer.lineno)
+  }
+  | pathSegments { result = prepare_path(false, false, val[0], self.lexer.lineno) }
+  ;
+
+pathSegments
+  : pathSegments SEP ID { result.push(s(:sep, val[1]), id(val[2])) }
+  | ID { result = [id(val[0])] }
+  ;
+
+# Extra rule needed to define none, used in the added rules
+none
+  : { result = nil }
+  ;
+
+---- header
+require "sexp"
+
+---- inner
+attr_reader :lexer
+
+def parse(str)
+  @lexer = HandlebarsLexer.new
+  lexer.scan_setup(str)
+  do_parse
+end
+
+def next_token
+  lexer.next_token
+end
+
+# Use pure ruby racc imlementation for debugging
+def do_parse
+  _racc_do_parse_rb(_racc_setup(), false)
+end
+
+def process_number(str)
+  if str =~ /\./
+    str.to_f
+  else
+    str.to_i
+  end
+end
+
+def strip_flags(start, finish)
+  s(:strip, start[2] == "~", finish[-3] == "~")
+end
+
+def strip_comment(comment)
+  comment.sub(/^\{\{~?!-?-?/, "").sub(/-?-?~?\}\}$/, "")
+end
+
+def id(val)
+  if (match = /\A\[(.*)\]\Z/.match val)
+    # TODO: Mark as having had square brackets
+    s(:id, match[1])
+  else
+    s(:id, val)
+  end
+end
+
+def interpret_open_token(open)
+  marker = open[2..-1][-1]
+  decorator = marker == "*"
+  escaped = !["{", "&"].include?(marker)
+  return decorator, escaped
+end
+
+def prepare_path(data, sexpr, parts, loc)
+  tail = []
+  parts.each_slice(2) do |part, sep|
+    if ["..", ".", "this"].include? part[1]
+      unless tail.empty?
+        path = tail.map { _1[1] }.join + part[1]
+        # TODO: keep track of the position in the line as well
+        raise ParseError, "Invalid path: #{path} - #{loc}"
+      end
+      next
+    end
+
+    tail << part
+    tail << sep if sep
+  end
+  # TODO: Handle sexpr
+  s(:path, data, *parts).line loc
+end
+
+def prepare_mustache(open, path, params, hash, close)
+  decorator, escaped = interpret_open_token(open)
+  type = decorator ? :directive : :mustache
+  s(type, path, params, hash, escaped, strip_flags(open, close)).line(self.lexer.lineno)
+end
+
+def prepare_partial_block(open, program, close)
+  _, name, params, hash, open_strip = *open
+  _, close_name, close_strip = *close
+
+  validate_close(name, close_name)
+
+  s(:partial_block, name, params, hash, program, open_strip, close_strip)
+    .line(self.lexer.lineno)
+end
+
+def prepare_raw_block(open, contents, close)
+  _open_type, path, params, hash, open_strip = *open
+  name = path[2][1]
+  validate_close(name, close)
+  close_strip = strip_flags(close, close)
+  s(:block, path, params, hash, contents, nil, open_strip, close_strip).line(self.lexer.lineno)
+end
+
+def prepare_block(open, program, inverse_chain, close, inverted)
+  open_type, name, params, hash, block_params, open_strip = *open
+  directive = open_type == :open_directive
+
+  raise ParseError, "Unexpected inverse" if directive && inverse_chain
+
+  if close
+    _, close_name, close_strip = *close
+    validate_close(name, close_name)
+  end
+
+  # TODO: Get close_strip from inverse_chain if close is nil
+
+  if inverted
+    raise NotImplementedError if inverse_chain
+    inverse_chain = s(:inverse, block_params, program, open_strip, close_strip)
+    program = nil
+  else
+    program = s(:program, block_params, program)
+  end
+
+  type = directive ? :directive_block : :block
+  s(type, name, params, hash, program, inverse_chain, open_strip, close_strip)
+    .line(self.lexer.lineno)
+end
+
+def validate_close(name, close_name)
+  unless name == close_name
+    raise ParseError, "#{name[2][1]} doesn't match #{close_name[2][1]}"
+  end
+end
+
+def on_error(t, val, vstack)
+  raise ParseError, sprintf("Parse error on line %i on value %s (%s) at %s",
+      self.lexer.lineno, val.inspect, token_to_str(t) || '?', vstack.inspect)
+end

data/lib/haparanda/handlebars_processor.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require "sexp_processor"
+
+module Haparanda
+  class HandlebarsProcessor < SexpProcessor # rubocop:disable Metrics/ClassLength
+    class SafeString < String
+      def to_s
+        self
+      end
+    end
+
+    class Input
+      def initialize(value)
+        @stack = [value]
+      end
+
+      def dig(*keys)
+        index = -1
+        value = @stack[index]
+        keys.each do |key|
+          if key == :".."
+            index -= 1
+            value = @stack[index]
+          end
+          next if %i[.. . this].include? key
+
+          value = case value
+                  when Hash
+                    value[key]
+                  when nil
+                    nil
+                  else
+                    value.send key
+                  end
+        end
+
+        value
+      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
+          block.call
+        else
+          @stack.push value
+          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
+      end
+
+      def method_missing(method_name, *_args)
+        dig(method_name)
+      end
+    end
+
+    class Data
+      def initialize(data = {})
+        @data = data
+      end
+
+      def data(*keys)
+        @data.dig(*keys)
+      end
+
+      def set_data(key, value)
+        @data[key] = value
+      end
+
+      def with_new_data(&block)
+        data = @data.clone
+        result = block.call
+        @data = data
+        result
+      end
+
+      def respond_to_missing?(method_name)
+        @data.key? method_name
+      end
+
+      def method_missing(method_name, *_args)
+        @data[method_name] if @data.key? method_name
+      end
+    end
+
+    class NoData
+      def set_data(key, value); end
+
+      def with_new_data(&block)
+        block.call
+      end
+    end
+
+    class Options
+      def initialize(fn:, inverse:, hash:, data:)
+        @fn = fn
+        @inverse = inverse
+        @hash = hash
+        @data = data
+      end
+
+      attr_reader :hash, :data
+
+      def fn(arg = nil)
+        @fn&.call(arg)
+      end
+
+      def inverse(arg = nil)
+        @inverse&.call(arg)
+      end
+    end
+
+    def initialize(input, custom_helpers = nil, data: {})
+      super()
+
+      self.require_empty = false
+
+      @input = Input.new(input)
+      @data = data ? Data.new(data) : NoData.new
+
+      custom_helpers ||= {}
+      @helpers = {
+        if: method(:handle_if),
+        unless: method(:handle_unless),
+        with: method(:handle_with),
+        each: method(:handle_each)
+      }.merge(custom_helpers)
+    end
+
+    def apply(expr)
+      result = process(expr)
+      result[1]
+    end
+
+    def process_root(expr)
+      _, statements = expr
+      process(statements)
+    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
+      value = value.to_s
+      value = escape(value) if escaped
+      s(:result, value)
+    end
+
+    def process_block(expr)
+      _, name, params, hash, program, inverse_chain, = expr
+      hash = process(hash)[1] if 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)
+
+      evaluate_program_with_value(value, arguments, program, else_program, hash)
+    end
+
+    def process_statements(expr)
+      results = expr.sexp_body.map { process(_1)[1] }
+      s(:result, results.join)
+    end
+
+    def process_program(expr)
+      _, _params, statements, = expr
+      statements = process(statements)[1] if statements
+      s(:result, statements.to_s)
+    end
+
+    def process_comment(expr)
+      _, _comment, = expr
+      s(:result, "")
+    end
+
+    def process_path(expr)
+      _, data, *segments = expr
+      segments = segments.each_slice(2).map { |elem, _sep| elem[1].to_sym }
+      s(:segments, data, segments)
+    end
+
+    def process_exprs(expr)
+      _, *paths = expr
+      values = paths.map { evaluate_expr(_1) }
+      s(:values, values)
+    end
+
+    def process_hash(expr)
+      _, *entries = expr
+      hash = entries.to_h do |_, key, value|
+        value = evaluate_expr(value)
+        [key.to_sym, value]
+      end
+      s(:hash, hash)
+    end
+
+    private
+
+    def evaluate_program_with_value(value, arguments, program, else_program, hash)
+      fn = make_contextual_lambda(program)
+      inverse = make_contextual_lambda(else_program)
+
+      if value.respond_to? :call
+        value = execute_in_context(value, arguments, fn: fn, inverse: inverse, hash: hash)
+        return s(:result, value.to_s)
+      end
+
+      case value
+      when Array
+        return s(:result, inverse.call(@input)) if value.empty?
+
+        parts = value.each_with_index.map do |elem, index|
+          @data.set_data(:index, index)
+          fn.call(elem)
+        end
+        s(:result, parts.join)
+      else
+        result = value ? fn.call(value) : inverse.call(@input)
+        s(:result, result)
+      end
+    end
+
+    def make_contextual_lambda(program)
+      if program
+        ->(item) { @input.with_new_context(item) { apply(program) } }
+      else
+        ->(_item) { "" }
+      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
+        value
+      when :undefined, :null
+        nil
+      else
+        path[1]
+      end
+    end
+
+    def path_segments(path)
+      case path.sexp_type
+      when :segments
+        data, elements = path.sexp_body
+      when :undefined, :null
+        elements = [path.sexp_type]
+      else
+        elements = [path[1]]
+      end
+      return data, 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)
+      end
+    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)
+    end
+
+    def handle_if(value, options)
+      if value
+        options.fn(@input)
+      else
+        options.inverse(@input)
+      end
+    end
+
+    def handle_unless(value, options)
+      options.fn(@input) unless value
+    end
+
+    def handle_with(value, options)
+      if value
+        options.fn(value)
+      else
+        options.inverse(value)
+      end
+    end
+
+    def handle_each(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
+      end
+    end
+
+    ESCAPE = {
+      "&" => "&amp;",
+      "<" => "&lt;",
+      ">" => "&gt;",
+      '"' => "&quot;",
+      "'" => "&#x27;",
+      "`" => "&#x60;",
+      "=" => "&#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

data/lib/haparanda/template.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Haparanda
+  # Callable representation of a handlebars template
+  class Template
+    def initialize(expr, helpers)
+      @expr = expr
+      @helpers = helpers
+    end
+
+    def call(input, **runtime_options)
+      # TODO: Change interface of HandlebarsProcessor so it can be instantiated
+      # in Template#initialize
+      processor = HandlebarsProcessor.new(input, @helpers, **runtime_options)
+      processor.apply(@expr)
+    end
+  end
+end

data/lib/haparanda/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Current Haparanda version
+module Haparanda
+  VERSION = "0.0.1"
+end