haparanda 0.0.1

data/lib/haparanda/content_combiner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "sexp_processor"
+
+module Haparanda
+  # Process the handlebars AST just to combine subsequent :content items
+  class ContentCombiner < SexpProcessor
+    def initialize
+      super
+
+      self.require_empty = false
+    end
+
+    def process_statements(expr)
+      statements = expr.sexp_body
+
+      statements = combine_contents(statements)
+      statements = statements.map { process(_1) }
+
+      s(:statements, *statements)
+    end
+
+    private
+
+    def combine_contents(statements)
+      return statements if statements.length < 2
+
+      prev = nil
+      result = []
+
+      statements.each do |item|
+        if prev
+          if item.sexp_type == :content
+            prev[1] += item[1]
+          else
+            result << item
+            prev = nil
+          end
+        else
+          result << item
+          prev = item if item.sexp_type == :content
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/haparanda/handlebars_compiler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "content_combiner"
+require_relative "whitespace_handler"
+
+module Haparanda
+  # Process the handlebars AST just to combine subsequent :content items
+  class HandlebarsCompiler
+    def initialize(ignore_standalone: false, **)
+      @ignore_standalone = ignore_standalone
+    end
+
+    def process(expr)
+      expr = ContentCombiner.new.process(expr)
+      WhitespaceHandler.new(ignore_standalone: @ignore_standalone).process(expr)
+    end
+  end
+end

data/lib/haparanda/handlebars_lexer.rb

@@ -0,0 +1,297 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.8
+# from lexical definition file "lib/haparanda/handlebars_lexer.rex".
+#++
+
+# Based on src/handlebars.l in handlebars-parser.
+#
+# src/handlebars.l in handlebars-parser is covered by the ICS license. See README.md
+# for details.
+
+class Haparanda::HandlebarsLexer
+      require 'strscan'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
+
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
+
+
+        def next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/\n/))
+                     action { [:CONTENT, text] }
+
+                  when (text = @ss.scan(/[^\x00\n]*?(?={{)/))
+                     action {
+                                   if(text.slice(-2, 2) === "\\\\")
+                                     text = text[0..-2]
+                                     @state = :MU
+                                   elsif(text.slice(-1) === "\\")
+                                     text = text[0..-2]
+                                     @state = :EMU
+                                   else
+                                     @state = :MU
+                                   end
+                                   [:CONTENT, text] unless(text.empty?)
+                                 }
+
+
+                  when (text = @ss.scan(/[^\x00\n]+/))
+                     action { [:CONTENT, text] }
+
+                  when (text = @ss.scan(/<INITIAL,mu><<EOF>>/))
+                     action { [:EOF, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+            when :EMU
+          case
+                  when (text = @ss.scan(/{{/))
+                     action { @state = nil; [:CONTENT, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+            when :RAW
+          case
+                  when (text = @ss.scan(/{{{{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+}}}}/))
+                     action {
+                                  ending_delimiter = text[5...-4]
+                                  if ending_delimiter == @raw_delimiter
+                                    @state = nil
+                                    [:END_RAW_BLOCK, ending_delimiter]
+                                  else
+                                    [:CONTENT, text]
+                                  end
+                                 }
+
+
+                  when (text = @ss.scan(/[^\x00]+?(?={{{{)/))
+                     action { [:CONTENT, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+            when :COM
+          case
+                  when (text = @ss.scan(/[\s\S]*?\-\-~?}}/))
+                     action { @state = nil; [:COMMENT, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+            when :MU
+          case
+                  when (text = @ss.scan(/\(/))
+                     action { [:OPEN_SEXPR, text] }
+
+                  when (text = @ss.scan(/\)/))
+                     action { [:CLOSE_SEXPR, text] }
+
+                  when (text = @ss.scan(/{{{{/))
+                     action {
+                                   @expect_raw_block_id = true
+                                   [:OPEN_RAW_BLOCK, text]
+                                 }
+
+
+                  when (text = @ss.scan(/}}}}/))
+                     action {
+                                   @state = :RAW
+                                   [:CLOSE_RAW_BLOCK, text]
+                                 }
+
+
+                  when (text = @ss.scan(/{{~?>/))
+                     action { [:OPEN_PARTIAL, text] }
+
+                  when (text = @ss.scan(/{{~?#>/))
+                     action { [:OPEN_PARTIAL_BLOCK, text] }
+
+                  when (text = @ss.scan(/{{~?#\*?/))
+                     action { [:OPEN_BLOCK, text] }
+
+                  when (text = @ss.scan(/{{~?\//))
+                     action { [:OPEN_ENDBLOCK, text] }
+
+                  when (text = @ss.scan(/{{~?\^\s*~?}}/))
+                     action { @state = nil; [:INVERSE, text] }
+
+                  when (text = @ss.scan(/{{~?\s*else\s*~?}}/))
+                     action { @state = nil; [:INVERSE, text] }
+
+                  when (text = @ss.scan(/{{~?\^/))
+                     action { [:OPEN_INVERSE, text] }
+
+                  when (text = @ss.scan(/{{~?\s*else/))
+                     action { [:OPEN_INVERSE_CHAIN, text] }
+
+                  when (text = @ss.scan(/{{~?{/))
+                     action { [:OPEN_UNESCAPED, text] }
+
+                  when (text = @ss.scan(/{{~?&/))
+                     action { [:OPEN, text] }
+
+                  when (text = @ss.scan(/{{~?!--/))
+                     action { @state = :COM; [:COMMENT, text] }
+
+                  when (text = @ss.scan(/{{~?![\s\S]*?}}/))
+                     action { @state = nil; [:COMMENT, text] }
+
+                  when (text = @ss.scan(/{{~?\*?/))
+                     action { [:OPEN, text] }
+
+                  when (text = @ss.scan(/=/))
+                     action { [:EQUALS, text] }
+
+                  when (text = @ss.scan(/\.\./))
+                     action { [:ID, text] }
+
+                  when (text = @ss.scan(/\.(?=[=~}\s\/.)|])/))
+                     action { [:ID, text] }
+
+                  when (text = @ss.scan(/[\/.]/))
+                     action { [:SEP, text] }
+
+                  when (text = @ss.scan(/\s+/))
+                    ;
+
+                  when (text = @ss.scan(/}~?}}/))
+                     action { @state = nil; [:CLOSE_UNESCAPED, text] }
+
+                  when (text = @ss.scan(/~?}}/))
+                     action { @state = nil; [:CLOSE, text] }
+
+                  when (text = @ss.scan(/"(\\"|[^"])*"/))
+                     action { text = handle_stringescape(text, '"'); [:STRING, text] }
+
+                  when (text = @ss.scan(/'(\\'|[^'])*'/))
+                     action { text = handle_stringescape(text, "'"); [:STRING, text] }
+
+                  when (text = @ss.scan(/@/))
+                     action { [:DATA, text] }
+
+                  when (text = @ss.scan(/true(?=[~}\s)])/))
+                     action { [:BOOLEAN, text] }
+
+                  when (text = @ss.scan(/false(?=[~}\s)])/))
+                     action { [:BOOLEAN, text] }
+
+                  when (text = @ss.scan(/undefined(?=[~}\s)])/))
+                     action { [:UNDEFINED, text] }
+
+                  when (text = @ss.scan(/null(?=[~}\s)])/))
+                     action { [:NULL, text] }
+
+                  when (text = @ss.scan(/\-?[0-9]+(?:\.[0-9]+)?(?=[~}\s)])/))
+                     action { [:NUMBER, text] }
+
+                  when (text = @ss.scan(/as\s+\|/))
+                     action { [:OPEN_BLOCK_PARAMS, text] }
+
+                  when (text = @ss.scan(/\|/))
+                     action { [:CLOSE_BLOCK_PARAMS, text] }
+
+                  when (text = @ss.scan(/[^\s!"\#%-,\.\/;->@\[-\^`\{-~]+(?=[=~}\s\/.)|])=/))
+                     action { [:KEY_ASSIGN, text[0..-2]] }
+
+                  when (text = @ss.scan(/[^\s!"\#%-,\.\/;->@\[-\^`\{-~]+(?=[=~}\s\/.)|])/))
+                     action {
+                                   if @expect_raw_block_id
+                                     @raw_delimiter = text
+                                     @expect_raw_block_id = false
+                                   end
+                                   [:ID, text]
+                                 }
+
+
+                  when (text = @ss.scan(/\[(\\\]|[^\]])*\]/))
+                     action { text = text.gsub(/\\([\\\]])/, '\1'); [:ID, text] }
+
+                  when (text = @ss.scan(/./))
+                     action { [:INVALID, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
+
+    def do_parse
+      result = []
+      while token = next_token
+        result << token
+      end
+      result
+    end
+    def handle_stringescape(str, delimiter)
+      case delimiter
+      when '"', "'"
+        str[1..-2].gsub(%r{\\(.)}, "\\1")
+      else
+        raise NotImplementedError
+      end
+    end
+end # class

data/lib/haparanda/handlebars_lexer.rex

@@ -0,0 +1,135 @@
+# Based on src/handlebars.l in handlebars-parser.
+#
+# src/handlebars.l in handlebars-parser is covered by the ICS license. See README.md
+# for details.
+
+class Haparanda::HandlebarsLexer
+%x mu emu com raw
+
+inner
+
+    def do_parse
+      result = []
+      while token = next_token
+        result << token
+      end
+      result
+    end
+
+    def handle_stringescape(str, delimiter)
+      case delimiter
+      when '"', "'"
+        str[1..-2].gsub(%r{\\(.)}, "\\1")
+      else
+        raise NotImplementedError
+      end
+    end
+
+macro
+LEFT_STRIP    ~
+RIGHT_STRIP   ~
+
+LOOKAHEAD           [=~}\s\/.)|]
+LIT_LOOKAHEAD       [~}\s)]
+
+# ID is the inverse of control characters.
+# Control characters ranges:
+#   [\s]          Whitespace
+#   [!"#%-,\./]   !, ", #, %, &, ', (, ), *, +, ,, ., /,  Exceptions in range: $, -
+#   [;->@]        ;, <, =, >, @,                          Exceptions in range: :, ?
+#   [\[-\^`]      [, \, ], ^, `,                          Exceptions in range: _
+#   [\{-~]        {, |, }, ~
+ID    [^\s!"\#%-,\.\/;->@\[-\^`\{-~]+(?={LOOKAHEAD})
+
+rule
+
+\n                               { [:CONTENT, text] }
+[^\x00\n]*?(?={{)                {
+                                   if(text.slice(-2, 2) === "\\\\")
+                                     text = text[0..-2]
+                                     @state = :MU
+                                   elsif(text.slice(-1) === "\\")
+                                     text = text[0..-2]
+                                     @state = :EMU
+                                   else
+                                     @state = :MU
+                                   end
+                                   [:CONTENT, text] unless(text.empty?)
+                                 }
+
+[^\x00\n]+                       { [:CONTENT, text] }
+
+# consume escaped mustache
+:EMU {{                          { @state = nil; [:CONTENT, text] }
+
+# End of raw block if delimiter text matches opening text
+:RAW {{{{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+}}}} {
+                                  ending_delimiter = text[5...-4]
+                                  if ending_delimiter == @raw_delimiter
+                                    @state = nil
+                                    [:END_RAW_BLOCK, ending_delimiter]
+                                  else
+                                    [:CONTENT, text]
+                                  end
+                                 }
+:RAW [^\x00]+?(?={{{{)           { [:CONTENT, text] }
+
+:COM [\s\S]*?\-\-{RIGHT_STRIP}?}}   { @state = nil; [:COMMENT, text] }
+
+:MU \(                           { [:OPEN_SEXPR, text] }
+:MU \)                           { [:CLOSE_SEXPR, text] }
+
+:MU {{{{                         {
+                                   @expect_raw_block_id = true
+                                   [:OPEN_RAW_BLOCK, text]
+                                 }
+:MU }}}}                         {
+                                   @state = :RAW
+                                   [:CLOSE_RAW_BLOCK, text]
+                                 }
+:MU {{{LEFT_STRIP}?>             { [:OPEN_PARTIAL, text] }
+:MU {{{LEFT_STRIP}?#>            { [:OPEN_PARTIAL_BLOCK, text] }
+:MU {{{LEFT_STRIP}?#\*?          { [:OPEN_BLOCK, text] }
+:MU {{{LEFT_STRIP}?\/            { [:OPEN_ENDBLOCK, text] }
+:MU {{{LEFT_STRIP}?\^\s*{RIGHT_STRIP}?}}      { @state = nil; [:INVERSE, text] }
+:MU {{{LEFT_STRIP}?\s*else\s*{RIGHT_STRIP}?}} { @state = nil; [:INVERSE, text] }
+:MU {{{LEFT_STRIP}?\^            { [:OPEN_INVERSE, text] }
+:MU {{{LEFT_STRIP}?\s*else       { [:OPEN_INVERSE_CHAIN, text] }
+:MU {{{LEFT_STRIP}?{             { [:OPEN_UNESCAPED, text] }
+:MU {{{LEFT_STRIP}?&             { [:OPEN, text] }
+:MU {{{LEFT_STRIP}?!--           { @state = :COM; [:COMMENT, text] }
+:MU {{{LEFT_STRIP}?![\s\S]*?}}   { @state = nil; [:COMMENT, text] }
+:MU {{{LEFT_STRIP}?\*?           { [:OPEN, text] }
+
+:MU =                            { [:EQUALS, text] }
+:MU \.\.                         { [:ID, text] }
+:MU \.(?={LOOKAHEAD})            { [:ID, text] }
+:MU [\/.]                        { [:SEP, text] }
+:MU \s+                          // ignore whitespace
+:MU }{RIGHT_STRIP}?}}            { @state = nil; [:CLOSE_UNESCAPED, text] }
+:MU {RIGHT_STRIP}?}}             { @state = nil; [:CLOSE, text] }
+:MU "(\\"|[^"])*"                { text = handle_stringescape(text, '"'); [:STRING, text] }
+:MU '(\\'|[^'])*'                { text = handle_stringescape(text, "'"); [:STRING, text] }
+:MU @                            { [:DATA, text] }
+:MU true(?={LIT_LOOKAHEAD})      { [:BOOLEAN, text] }
+:MU false(?={LIT_LOOKAHEAD})     { [:BOOLEAN, text] }
+:MU undefined(?={LIT_LOOKAHEAD}) { [:UNDEFINED, text] }
+:MU null(?={LIT_LOOKAHEAD})      { [:NULL, text] }
+:MU \-?[0-9]+(?:\.[0-9]+)?(?={LIT_LOOKAHEAD}) { [:NUMBER, text] }
+:MU as\s+\|                      { [:OPEN_BLOCK_PARAMS, text] }
+:MU \|                           { [:CLOSE_BLOCK_PARAMS, text] }
+
+:MU {ID}=                        { [:KEY_ASSIGN, text[0..-2]] }
+:MU {ID}                         {
+                                   if @expect_raw_block_id
+                                     @raw_delimiter = text
+                                     @expect_raw_block_id = false
+                                   end
+                                   [:ID, text]
+                                 }
+
+:MU \[(\\\]|[^\]])*\]            { text = text.gsub(/\\([\\\]])/, '\1'); [:ID, text] }
+:MU .                            { [:INVALID, text] }
+
+<INITIAL,mu><<EOF>>              { [:EOF, text] }
+end