haparanda 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3cc196820e7b050365c1dd7e5b4ecaa7bc1773c1540e72a6e455dbb12db4b0a
-  data.tar.gz: 4fd2fa30a9e21a6e90b888a101735500896e18cf70030dfd7ac9f8f895572f14
+  metadata.gz: dac0fe913e8e3d23afb7d2d25b6a74543c95a023502edb2a1dcfb2e38c32d12a
+  data.tar.gz: 6e25ca71f28f0893e71f919d79c333f6e144ada574d1943a2fb6a8f17308148e
 SHA512:
-  metadata.gz: c0acc72023896cc5b161a3300ddba3567657ae3062caf847334c2df3066e3cac4f523655c99e78059dce8f2d23c5d83db4f52d5bd251d6f9c9e896c63603d8a5
-  data.tar.gz: 1e37a97a62346d236d53d3d6cf51768537ded9e4d061dcf314334cfec030ff403564e0acd80ea41021ef2a4308c7c2451a0fb6d727f2c0cd3c22f3f43433b4f9
+  metadata.gz: b8dae9b686c0bd33abadd8c30c794b07d642b196669d0fcb952f344901c2b7418f2c16999e74859ab75d5e5cbaf5a5da4b34b59aa487447cd1a570b6fb093598
+  data.tar.gz: f3ad2bceb64be087c3ef5a5b61d37bf35ecf3b01eb4b747f1148f28ddb6eca771e13605107d9a7cf8a24b5dbe0759985a87ec6214230be291100bd9e488ad121

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.0.2 / 2025-11-23
+
+This release implements the functionality needed to pass the relevant parts of
+the handlebars spec suite as translated to Ruby, and those parts of the
+mustache spec that handlebars.js also passes.
+
+See the [full git log](https://github.com/mvz/haparanda/compare/v0.0.1...v0.0.2)
+for details.
+
 ## 0.0.1 / 2025-03-31
 
 * Initial release

data/README.md

@@ -13,7 +13,7 @@ require "haparanda"
 
 hbs = Haparanda::Compiler.new
 hbs.register_partial 'full_name', "{{person.first_name}} {{person.last_name}}"
-hbs.register_helper :foo do
+hbs.register_helper :foo do |context, bar, baz, options|
   ...
 end
 template = hbs.compile(template_text) # Returns Haparanda::Template
@@ -27,7 +27,6 @@ template.call input  # or template.call({ foo: "Bar", baz: "Qux" })
 
 ## Compatibility Notes
 
-- When using a hash as input, symbols keys and string keys are considered different
 - Currently targets handlebars.js master
 
 ## Install
@@ -69,6 +68,9 @@ gem install haparanda
   ```ruby
   hbs = Handlebars::Handlebars.new
   hbs.register_partial('full_name', "{{person.first_name}} {{person.last_name}}")
+  hbs.register_helper(:foo) do |context, bar, baz, block, else_block|
+    ...
+  end
   template = hbs.compile("Hello {{> full_name}}")
   template.call({person: {first_name: 'Pinkie', last_name: 'Pie'}})
   ```

data/lib/haparanda/compiler.rb

@@ -1,29 +1,69 @@
 # frozen_string_literal: true
 
+require "logger"
 require_relative "template"
+require_relative "parser"
 
 module Haparanda
   # Compile handlebars template to a callable Haparanda::Template object
   class Compiler
-    def initialize(**compile_options)
-      @parser = HandlebarsParser.new
-      # TODO: Rename to PostProcessor
-      @post_processor = HandlebarsCompiler.new(**compile_options)
+    def initialize
       @helpers = {}
+      @partials = {}
+      @log = nil
     end
 
-    def compile(text)
-      template = parser.parse(text)
-      compiled_template = post_processor.process(template)
-      Template.new(compiled_template, @helpers)
+    def compile(text, **compile_options)
+      ast = template_to_ast text, **compile_options
+      Template.new(ast, @helpers, @partials, @log, **compile_options)
     end
 
     def register_helper(name, &definition)
-      @helpers[name] = definition
+      @helpers[name.to_sym] = definition
     end
 
+    def register_helpers(**helpers)
+      helpers.each do |name, definition|
+        register_helper(name, &definition)
+      end
+    end
+
+    def unregister_helper(name)
+      @helpers.delete(name.to_sym)
+    end
+
+    def get_helper(name)
+      @helpers[name.to_sym]
+    end
+
+    def register_partial(name, content)
+      unless content
+        raise "Attempting to register a partial called \"#{name}\" as #{content.inspect}"
+      end
+
+      @partials[name.to_s] = template_to_ast(content)
+    end
+
+    def register_partials(**partials)
+      partials.each do |name, content|
+        register_partial(name, content)
+      end
+    end
+
+    def unregister_partial(name)
+      @partials.delete(name.to_s)
+    end
+
+    def get_partial(name)
+      @partials[name.to_s]
+    end
+
+    attr_accessor :log
+
     private
 
-    attr_reader :parser, :post_processor
+    def template_to_ast(text, **compile_options)
+      Parser.new(**compile_options).parse(text)
+    end
   end
 end

data/lib/haparanda/content_combiner.rb

@@ -20,6 +20,11 @@ module Haparanda
       s(:statements, *statements)
     end
 
+    def process(expr)
+      line = expr.line
+      super.tap { _1.line(line) if line }
+    end
+
     private
 
     def combine_contents(statements)
@@ -32,6 +37,8 @@ module Haparanda
         if prev
           if item.sexp_type == :content
             prev[1] += item[1]
+            # TODO: Enable this and make line_max propagate up
+            # prev.line_max = item.line
           else
             result << item
             prev = nil

data/lib/haparanda/handlebars_parser.rb

@@ -12,7 +12,7 @@ require "sexp"
 module Haparanda
   class HandlebarsParser < Racc::Parser
 
-module_eval(<<'...end handlebars_parser.y/module_eval...', 'handlebars_parser.y', 231)
+module_eval(<<'...end handlebars_parser.y/module_eval...', 'handlebars_parser.y', 235)
 attr_reader :lexer
 
 def parse(str)
@@ -48,8 +48,7 @@ end
 
 def id(val)
   if (match = /\A\[(.*)\]\Z/.match val)
-    # TODO: Mark as having had square brackets
-    s(:id, match[1])
+    s(:id, match[1], true)
   else
     s(:id, val)
   end
@@ -63,19 +62,19 @@ def interpret_open_token(open)
 end
 
 def prepare_path(data, sexpr, parts, loc)
-  tail = []
+  prefix = []
   parts.each_slice(2) do |part, sep|
     if ["..", ".", "this"].include? part[1]
-      unless tail.empty?
-        path = tail.map { _1[1] }.join + part[1]
+      unless prefix.empty? || part[2]
+        path = prefix.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
+    prefix << part
+    prefix << sep if sep
   end
   # TODO: Handle sexpr
   s(:path, data, *parts).line loc
@@ -118,12 +117,15 @@ def prepare_block(open, program, inverse_chain, close, inverted)
 
   # TODO: Get close_strip from inverse_chain if close is nil
 
+  program_line = program&.line
   if inverted
     raise NotImplementedError if inverse_chain
     inverse_chain = s(:inverse, block_params, program, open_strip, close_strip)
+    inverse_chain.line program_line if program_line
     program = nil
   else
     program = s(:program, block_params, program)
+    program.line program_line if program_line
   end
 
   type = directive ? :directive_block : :block
@@ -504,9 +506,11 @@ Racc_debug_parser = false
 
 # reduce 1 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 22)
+module_eval(<<'.,.,', 'handlebars_parser.y', 23)
   def _reduce_2(val, _values, result)
-     result = s(:root, val[0])
+        result = s(:root, val[0])
+    result.line(val[0].line) if val[0]
+
     result
   end
 .,.,
@@ -515,14 +519,14 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 22)
 
 # reduce 4 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 32)
+module_eval(<<'.,.,', 'handlebars_parser.y', 34)
   def _reduce_5(val, _values, result)
-     result = s(:statements, val[0])
+     result = s(:statements, val[0]).line(val[0].line)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 33)
+module_eval(<<'.,.,', 'handlebars_parser.y', 35)
   def _reduce_6(val, _values, result)
      result << val[1]
     result
@@ -541,7 +545,7 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 33)
 
 # reduce 12 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 44)
+module_eval(<<'.,.,', 'handlebars_parser.y', 46)
   def _reduce_13(val, _values, result)
         result = s(:comment, strip_comment(val[0]), strip_flags(val[0], val[0]))
       .line(self.lexer.lineno)
@@ -550,7 +554,7 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 44)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 50)
+module_eval(<<'.,.,', 'handlebars_parser.y', 52)
   def _reduce_14(val, _values, result)
         result = s(:content, val[0])
     result.line = self.lexer.lineno
@@ -559,7 +563,7 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 50)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 58)
+module_eval(<<'.,.,', 'handlebars_parser.y', 60)
   def _reduce_15(val, _values, result)
         result = s(:content, "")
     result.line = self.lexer.lineno
@@ -572,7 +576,7 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 58)
 
 # reduce 17 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 68)
+module_eval(<<'.,.,', 'handlebars_parser.y', 70)
   def _reduce_18(val, _values, result)
         result[1] += val[1]
 
@@ -580,14 +584,14 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 68)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 73)
+module_eval(<<'.,.,', 'handlebars_parser.y', 75)
   def _reduce_19(val, _values, result)
      result = prepare_raw_block(val[0], val[1], val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 78)
+module_eval(<<'.,.,', 'handlebars_parser.y', 80)
   def _reduce_20(val, _values, result)
         result = s(:open_raw, *val[1..3], strip_flags(val[0], val[4])).line(self.lexer.lineno)
 
@@ -595,21 +599,21 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 78)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 83)
+module_eval(<<'.,.,', 'handlebars_parser.y', 85)
   def _reduce_21(val, _values, result)
      result = prepare_block(val[0], val[1], val[2], val[3], false)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 84)
+module_eval(<<'.,.,', 'handlebars_parser.y', 86)
   def _reduce_22(val, _values, result)
       result = prepare_block(val[0], val[1], val[2], val[3], true)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 89)
+module_eval(<<'.,.,', 'handlebars_parser.y', 91)
   def _reduce_23(val, _values, result)
         decorator, _escaped = interpret_open_token(val[0])
     type = decorator ? :open_directive : :open
@@ -619,14 +623,14 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 89)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 96)
+module_eval(<<'.,.,', 'handlebars_parser.y', 98)
   def _reduce_24(val, _values, result)
      result = s(:open, val[1], val[2], val[3], val[4], strip_flags(val[0], val[5]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 100)
+module_eval(<<'.,.,', 'handlebars_parser.y', 102)
   def _reduce_25(val, _values, result)
      result = s(:open, val[1], val[2], val[3], val[4], strip_flags(val[0], val[5]))
     result
@@ -637,19 +641,21 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 100)
 
 # reduce 27 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 110)
+module_eval(<<'.,.,', 'handlebars_parser.y', 113)
   def _reduce_28(val, _values, result)
-     result = s(:inverse, nil, val[1], strip_flags(val[0], val[0]), nil)
+        result = s(:inverse, nil, val[1], strip_flags(val[0], val[0]), nil)
+    result.line(val[1].line) if val[1]
+
     result
   end
 .,.,
 
 # reduce 29 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 116)
+module_eval(<<'.,.,', 'handlebars_parser.y', 120)
   def _reduce_30(val, _values, result)
         block = prepare_block(val[0], val[1], val[2], nil, false)
-    result = s(:inverse, nil, block, nil, nil)
+    result = s(:inverse, nil, block, nil, nil).line(block.line)
 
     result
   end
@@ -657,44 +663,44 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 116)
 
 # reduce 31 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 123)
+module_eval(<<'.,.,', 'handlebars_parser.y', 127)
   def _reduce_32(val, _values, result)
      result = s(:close, val[1], strip_flags(val[0], val[2]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 127)
+module_eval(<<'.,.,', 'handlebars_parser.y', 131)
   def _reduce_33(val, _values, result)
      result = prepare_mustache(*val)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 128)
+module_eval(<<'.,.,', 'handlebars_parser.y', 132)
   def _reduce_34(val, _values, result)
      result = prepare_mustache(*val)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 133)
+module_eval(<<'.,.,', 'handlebars_parser.y', 137)
   def _reduce_35(val, _values, result)
-        result = s(:partial, val[1], val[2], val[3], strip_flags(val[0], val[4]))
+        result = s(:partial, val[1], val[2], val[3], nil, strip_flags(val[0], val[4]))
       .line(self.lexer.lineno)
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 139)
+module_eval(<<'.,.,', 'handlebars_parser.y', 143)
   def _reduce_36(val, _values, result)
      result = prepare_partial_block(*val)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 143)
+module_eval(<<'.,.,', 'handlebars_parser.y', 147)
   def _reduce_37(val, _values, result)
      result = s(:open_partial, val[1], val[2], val[3], strip_flags(val[0], val[4]))
     result
@@ -705,7 +711,7 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 143)
 
 # reduce 39 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 153)
+module_eval(<<'.,.,', 'handlebars_parser.y', 157)
   def _reduce_40(val, _values, result)
      result = s(:exprs)
     result
@@ -714,21 +720,21 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 153)
 
 # reduce 41 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 159)
+module_eval(<<'.,.,', 'handlebars_parser.y', 163)
   def _reduce_42(val, _values, result)
      result = s(:exprs, val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 160)
+module_eval(<<'.,.,', 'handlebars_parser.y', 164)
   def _reduce_43(val, _values, result)
      result.push(val[1])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 165)
+module_eval(<<'.,.,', 'handlebars_parser.y', 169)
   def _reduce_44(val, _values, result)
         result = s(:sub_expression, val[1], val[2], val[3]).line self.lexer.lineno
 
@@ -738,28 +744,28 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 165)
 
 # reduce 45 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 170)
+module_eval(<<'.,.,', 'handlebars_parser.y', 174)
   def _reduce_46(val, _values, result)
      result = result.line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 175)
+module_eval(<<'.,.,', 'handlebars_parser.y', 179)
   def _reduce_47(val, _values, result)
      result = s(:hash, val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 176)
+module_eval(<<'.,.,', 'handlebars_parser.y', 180)
   def _reduce_48(val, _values, result)
      result.push(val[1])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 180)
+module_eval(<<'.,.,', 'handlebars_parser.y', 184)
   def _reduce_49(val, _values, result)
      result = s(:hash_pair, val[0], val[1]).line(self.lexer.lineno)
     result
@@ -768,21 +774,21 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 180)
 
 # reduce 50 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 185)
+module_eval(<<'.,.,', 'handlebars_parser.y', 189)
   def _reduce_51(val, _values, result)
      result = s(:block_params, *val[1])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 190)
+module_eval(<<'.,.,', 'handlebars_parser.y', 194)
   def _reduce_52(val, _values, result)
      result = [id(val[0])]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 191)
+module_eval(<<'.,.,', 'handlebars_parser.y', 195)
   def _reduce_53(val, _values, result)
      result << id(val[1])
     result
@@ -793,49 +799,49 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 191)
 
 # reduce 55 omitted
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 197)
+module_eval(<<'.,.,', 'handlebars_parser.y', 201)
   def _reduce_56(val, _values, result)
      result = s(:string, val[0]).line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 198)
+module_eval(<<'.,.,', 'handlebars_parser.y', 202)
   def _reduce_57(val, _values, result)
      result = s(:number, process_number(val[0])).line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 199)
+module_eval(<<'.,.,', 'handlebars_parser.y', 203)
   def _reduce_58(val, _values, result)
      result = s(:boolean, val[0] == "true").line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 200)
+module_eval(<<'.,.,', 'handlebars_parser.y', 204)
   def _reduce_59(val, _values, result)
      result = s(:undefined).line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 201)
+module_eval(<<'.,.,', 'handlebars_parser.y', 205)
   def _reduce_60(val, _values, result)
      result = s(:null).line(self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 205)
+module_eval(<<'.,.,', 'handlebars_parser.y', 209)
   def _reduce_61(val, _values, result)
      result = prepare_path(true, false, val[1], self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 210)
+module_eval(<<'.,.,', 'handlebars_parser.y', 214)
   def _reduce_62(val, _values, result)
         # NOTE: Separator is always parsed as '/'
     result = prepare_path(false, false, [val[0], s(:sep, "/"), *val[2]], self.lexer.lineno)
@@ -844,28 +850,28 @@ module_eval(<<'.,.,', 'handlebars_parser.y', 210)
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 213)
+module_eval(<<'.,.,', 'handlebars_parser.y', 217)
   def _reduce_63(val, _values, result)
      result = prepare_path(false, false, val[0], self.lexer.lineno)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 217)
+module_eval(<<'.,.,', 'handlebars_parser.y', 221)
   def _reduce_64(val, _values, result)
      result.push(s(:sep, val[1]), id(val[2]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 218)
+module_eval(<<'.,.,', 'handlebars_parser.y', 222)
   def _reduce_65(val, _values, result)
      result = [id(val[0])]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'handlebars_parser.y', 223)
+module_eval(<<'.,.,', 'handlebars_parser.y', 227)
   def _reduce_66(val, _values, result)
      result = nil
     result