haparanda 0.0.1 → 0.0.2

data/lib/haparanda/parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "content_combiner"
+require_relative "standalone_whitespace_handler"
+require_relative "whitespace_stripper"
+
+module Haparanda
+  # Parse a handlebars string to an AST in the form needed to apply input to it:
+  # - parse the string into the raw AST
+  # - combine subsequent :content items
+  # - strip whitespace according to Handlebars' rules
+  class Parser
+    def initialize(ignore_standalone: false, prevent_indent: false, **)
+      @ignore_standalone = ignore_standalone
+      @prevent_indent = prevent_indent
+    end
+
+    def parse(text)
+      expr = HandlebarsParser.new.parse(text)
+      expr = ContentCombiner.new.process(expr)
+      unless @ignore_standalone
+        expr = StandaloneWhitespaceHandler.new(prevent_indent: @prevent_indent)
+                                          .process(expr)
+      end
+      WhitespaceStripper.new.process(expr)
+    end
+  end
+end

data/lib/haparanda/standalone_whitespace_handler.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "sexp_processor"
+
+module Haparanda
+  # Process the handlebars AST just to do the whitespace stripping.
+  class StandaloneWhitespaceHandler < SexpProcessor # rubocop:todo Metrics/ClassLength
+    def initialize(prevent_indent: false)
+      super()
+
+      @prevent_indent = prevent_indent
+      self.require_empty = false
+    end
+
+    def process(expr)
+      line = expr&.line
+      super.tap { _1.line(line) if line }
+    end
+
+    def process_root(expr)
+      _, statements = expr
+
+      @root = true
+      statements = process(statements)
+      s(:root, statements)
+    end
+
+    def process_block(expr)
+      _, name, params, hash, program, inverse_chain, open_strip, close_strip = expr
+
+      program = process(program)
+      inverse_chain = process(inverse_chain)
+
+      statements = program&.at(2)&.sexp_body
+
+      if statements && inverse_chain
+        strip_standalone_whitespace(statements.last, first_item(inverse_chain))
+      end
+
+      s(:block, name, params, hash, program, inverse_chain, open_strip, close_strip)
+    end
+
+    def process_statements(expr)
+      statements = expr.sexp_body
+
+      strip_whitespace_around_standalone_items(statements)
+
+      s(:statements, *statements)
+    end
+
+    private
+
+    # Strip whitespace around standalone items in a list of statements, while
+    # recursing the general processing into each item at the right moment.
+    #
+    # The goal is to correctly remove whitespace for each item that is
+    # 'standalone', i.e., appears on a line by itself with only whitespace
+    # around.
+    #
+    # The tricky bit is that removing whitespace for one item may remove the
+    # information needed for handling subsequent or nested items.
+    #
+    # To resolve this, this method splits the collection of what whitespace
+    # changes to make from actually making them. In between these two parts, it
+    # recurses into the nested items. This way, it ensures the nested process
+    # has the original information available.
+    # rubocop:todo Metrics/PerceivedComplexity
+    # rubocop:todo Metrics/MethodLength
+    def strip_whitespace_around_standalone_items(statements) # rubocop:todo Metrics/AbcSize
+      before = nil
+
+      root = @root
+      @root = false
+      last_idx = statements.length - 1
+
+      [*statements, nil].each_cons(2).with_index do |(item, after), idx|
+        before_space, inner_start_space, inner_end_space, after_space =
+          collect_whitespace_information(before, item, after)
+
+        if root
+          if [:block, :comment].include?(item.sexp_type)
+            before_space = true if idx == 0
+            after_space = true if idx == last_idx
+          end
+          if [:block, :comment, :partial].include?(item.sexp_type) &&
+             idx == 1 && before.sexp_type == :content && (before[1] =~ /^\s*$/)
+            before_space = true
+          end
+
+          after_space = true if [:partial].include?(item.sexp_type) && idx == last_idx
+        end
+
+        process(item)
+
+        apply_whitespace_clearing(before, item, after,
+                                  before_space, inner_start_space,
+                                  inner_end_space, after_space)
+
+        before = item
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def collect_whitespace_information(before, item, after)
+      before_space = preceding_whitespace? before
+      after_space = following_whitespace? after
+
+      if item.sexp_type == :block
+        inner_start_space = following_whitespace? first_item(item)
+        inner_end_space = preceding_whitespace? last_item(item)
+      end
+      return before_space, inner_start_space, inner_end_space, after_space
+    end
+
+    # rubocop:todo Metrics/PerceivedComplexity
+    # rubocop:todo Metrics/CyclomaticComplexity
+    def apply_whitespace_clearing(before, item, after, # rubocop:todo Metrics/MethodLength
+                                  before_space, inner_start_space,
+                                  inner_end_space, after_space)
+      case item.sexp_type
+      when :block
+        if before_space && inner_start_space
+          clear_preceding_whitespace(before)
+          clear_following_whitespace(first_item(item))
+        end
+
+        if inner_end_space && after_space
+          clear_preceding_whitespace(last_item(item))
+          clear_following_whitespace(after)
+        end
+      when :partial
+        if !@prevent_indent && before_space && after_space
+          indent = clear_preceding_whitespace(before)
+          set_indent(item, indent)
+        end
+        clear_following_whitespace(after) if before_space && after
+      when :comment
+        if before_space && after_space
+          clear_preceding_whitespace(before)
+          clear_following_whitespace(after)
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def first_item(container)
+      return if container.nil?
+
+      case container.sexp_type
+      when :statements
+        container.sexp_body.first
+      when :block
+        first_item(container[4] || container[5])
+      when :inverse, :program
+        first_item container[2]
+      when :content
+        container
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def last_item(container)
+      return if container.nil?
+
+      case container.sexp_type
+      when :statements
+        container.sexp_body.last
+      when :block
+        last_item(container[5] || container[4])
+      when :inverse, :program
+        last_item container[2]
+      when :content
+        container
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def strip_standalone_whitespace(before, after)
+      return unless preceding_whitespace? before
+      return unless following_whitespace? after
+
+      clear_preceding_whitespace(before)
+      clear_following_whitespace(after)
+    end
+
+    def preceding_whitespace?(before)
+      before&.sexp_type == :content && before[1] =~ /\n\s*\z/
+    end
+
+    def following_whitespace?(after)
+      after&.sexp_type == :content && after[1] =~ /^\s*\n/
+    end
+
+    # Strip trailing whitespace before but leave the \n. Return the stripped space.
+    def clear_preceding_whitespace(before)
+      return unless before
+
+      if (match = before[1].match(/\A(.*\n|)([ \t]+)\Z/m))
+        before[1] = match[1]
+        match[2]
+      end
+    end
+
+    # Strip leading whitespace after, including the \n if present
+    def clear_following_whitespace(after)
+      return unless after
+
+      after[1] = after[1].sub(/^[ \t]*(\n|\r\n)?/, "")
+    end
+
+    def set_indent(item, indent)
+      unless item.sexp_type == :partial
+        raise "Indenting not supported for #{item.sexp_type}"
+      end
+
+      item[-2] = s(:indent, indent)
+    end
+  end
+end

data/lib/haparanda/template.rb

@@ -1,18 +1,49 @@
 # frozen_string_literal: true
 
+require_relative "parser"
+
 module Haparanda
   # Callable representation of a handlebars template
   class Template
-    def initialize(expr, helpers)
+    def initialize(expr, helpers, partials, log, **compile_options)
       @expr = expr
       @helpers = helpers
+      @partials = partials
+      @log = log
+      @compile_options = compile_options
     end
 
-    def call(input, **runtime_options)
+    def call(input, helpers: {}, partials: {}, data: {})
+      all_helpers = @helpers.merge(helpers).compact
+      partials.transform_values! { parse_partial(_1) }
+      all_partials = @partials.merge(partials)
+      if @compile_options[:known_helpers_only]
+        keys = @compile_options[:known_helpers]&.keys || []
+        all_helpers = all_helpers.slice(*keys)
+      end
+      explicit_partial_context = true if @compile_options[:explicit_partial_context]
+      compat = true if @compile_options[:compat]
+      no_escape = true if @compile_options[:no_escape]
       # TODO: Change interface of HandlebarsProcessor so it can be instantiated
       # in Template#initialize
-      processor = HandlebarsProcessor.new(input, @helpers, **runtime_options)
+      processor =
+        HandlebarsProcessor.new(input,
+                                helpers: all_helpers,
+                                partials: all_partials,
+                                log: @log,
+                                data: data,
+                                compat: compat,
+                                explicit_partial_context: explicit_partial_context,
+                                no_escape: no_escape)
       processor.apply(@expr)
     end
+
+    private
+
+    def parse_partial(partial)
+      return partial if partial.respond_to? :call
+
+      Parser.new(**@compile_options).parse(partial)
+    end
   end
 end

data/lib/haparanda/version.rb

@@ -2,5 +2,5 @@
 
 # Current Haparanda version
 module Haparanda
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/haparanda/whitespace_stripper.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "sexp_processor"
+
+module Haparanda
+  # Process the handlebars AST just to do the whitespace stripping.
+  class WhitespaceStripper < SexpProcessor
+    def initialize
+      super
+
+      self.require_empty = false
+    end
+
+    def process(expr)
+      line = expr&.line
+      super.tap { _1.line(line) if line }
+    end
+
+    def process_root(expr)
+      _, statements = expr
+
+      statements = process(statements)
+      s(:root, statements)
+    end
+
+    def process_block(expr)
+      _, name, params, hash, program, inverse_chain, open_strip, close_strip = expr
+
+      program = process(program)
+      if inverse_chain && inverse_chain.last.nil?
+        body = inverse_chain.sexp_body
+        body[-1] = close_strip
+        inverse_chain.sexp_body = body
+      end
+      inverse_chain = process(inverse_chain)
+
+      statements = program&.at(2)&.sexp_body
+      if statements
+        strip_initial_whitespace(statements.first, open_strip)
+        strip_final_whitespace(statements.last, close_strip)
+      end
+
+      s(:block, name, params, hash, program, inverse_chain, open_strip, close_strip)
+    end
+
+    def process_partial_block(expr)
+      _, name, params, hash, statements, open_strip, close_strip = expr
+
+      if (statements = process(statements))
+        items = statements.sexp_body
+        strip_initial_whitespace(items.first, open_strip)
+        strip_final_whitespace(items.last, close_strip)
+      end
+
+      s(:partial_block, name, params, hash, statements, open_strip, close_strip)
+    end
+
+    def process_directive_block(expr)
+      _, name, params, hash, program, _inverse_chain, open_strip, close_strip = expr
+      program = process(program)
+
+      statements = program&.at(2)&.sexp_body
+      if statements
+        strip_initial_whitespace(statements.first, open_strip)
+        strip_final_whitespace(statements.last, close_strip)
+      end
+
+      s(:directive_block, name, params, hash, program, nil, open_strip, close_strip)
+    end
+
+    def process_inverse(expr)
+      _, block_params, statements, open_strip, close_strip = expr
+
+      block_params = process(block_params)
+      statements = process(statements)
+
+      case statements.sexp_type
+      when :statements
+        items = statements.sexp_body
+        strip_initial_whitespace(items.first, open_strip)
+        strip_final_whitespace(items.last, close_strip)
+      end
+      # TODO: Handle :block sexp_type
+
+      s(:inverse, block_params, statements, open_strip, close_strip)
+    end
+
+    def process_statements(expr)
+      statements = expr.sexp_body
+
+      strip_pairwise_sibling_whitespace(statements)
+
+      statements = statements.map { process(_1) }
+
+      s(:statements, *statements)
+    end
+
+    private
+
+    def strip_pairwise_sibling_whitespace(statements)
+      statements.each_cons(2) do |prev, item|
+        strip_final_whitespace(prev, open_strip_for(item)) if item.sexp_type != :content
+        strip_initial_whitespace(item, close_strip_for(prev)) if prev.sexp_type != :content
+      end
+    end
+
+    def strip_initial_whitespace(item, strip)
+      item[1] = item[1].sub(/^\s*/, "") if item.sexp_type == :content && strip[2]
+    end
+
+    def strip_final_whitespace(item, strip)
+      item[1] = item[1].sub(/\s*$/, "") if item.sexp_type == :content && strip&.at(1)
+    end
+
+    def open_strip_for(item)
+      case item.sexp_type
+      when :block, :directive_block, :partial_block
+        item.at(-2)
+      when :partial, :mustache, :comment
+        item.last
+      else
+        raise NotImplementedError, item.sexp_type
+      end
+    end
+
+    def close_strip_for(item)
+      case item.sexp_type
+      when :block, :directive_block, :partial_block, :partial, :mustache, :comment
+        item.last
+      else
+        raise NotImplementedError, item.sexp_type
+      end
+    end
+  end
+end

data/lib/haparanda.rb

@@ -9,7 +9,6 @@ require_relative "haparanda/version"
 
 require_relative "haparanda/handlebars_lexer"
 require_relative "haparanda/handlebars_parser"
-require_relative "haparanda/handlebars_compiler"
 require_relative "haparanda/handlebars_processor"
 
 require_relative "haparanda/compiler"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haparanda
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Matijs van Zuijlen
@@ -9,6 +9,20 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: racc
   requirement: !ruby/object:Gem::Requirement
@@ -54,16 +68,17 @@ files:
 - lib/haparanda.rb
 - lib/haparanda/compiler.rb
 - lib/haparanda/content_combiner.rb
-- lib/haparanda/handlebars_compiler.rb
 - lib/haparanda/handlebars_lexer.rb
 - lib/haparanda/handlebars_lexer.rex
 - lib/haparanda/handlebars_parser.output
 - lib/haparanda/handlebars_parser.rb
 - lib/haparanda/handlebars_parser.y
 - lib/haparanda/handlebars_processor.rb
+- lib/haparanda/parser.rb
+- lib/haparanda/standalone_whitespace_handler.rb
 - lib/haparanda/template.rb
 - lib/haparanda/version.rb
-- lib/haparanda/whitespace_handler.rb
+- lib/haparanda/whitespace_stripper.rb
 homepage: https://github.com/mvz/haparanda
 licenses:
 - LGPL-2.1-or-later
@@ -88,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Pure Ruby Handlebars Parser
 test_files: []

data/lib/haparanda/handlebars_compiler.rb

@@ -1,18 +0,0 @@
-# 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/whitespace_handler.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require "sexp_processor"
-
-module Haparanda
-  # Process the handlebars AST just to do the whitespace stripping.
-  class WhitespaceHandler < SexpProcessor # rubocop:disable Metrics/ClassLength
-    def initialize(ignore_standalone: false)
-      super()
-
-      @ignore_standalone = ignore_standalone
-
-      self.require_empty = false
-    end
-
-    def process_root(expr)
-      _, statements = expr
-
-      statements = process(statements)
-      item = statements.sexp_body[0]
-      if item.sexp_type == :block
-        content = item.dig(4, 2, 1)
-        clear_following_whitespace(content) if following_whitespace?(content)
-      end
-      s(:root, statements)
-    end
-
-    def process_block(expr)
-      _, name, params, hash, program, inverse_chain, open_strip, close_strip = expr
-
-      program = process(program)
-      if inverse_chain && inverse_chain.last.nil?
-        body = inverse_chain.sexp_body
-        body[-1] = close_strip
-        inverse_chain.sexp_body = body
-      end
-      inverse_chain = process(inverse_chain)
-
-      statements = program&.at(2)&.sexp_body
-      if statements
-        strip_initial_whitespace(statements.first, open_strip)
-        strip_final_whitespace(statements.last, close_strip)
-      end
-
-      if statements && inverse_chain
-        strip_standalone_whitespace(statements.last, first_item(inverse_chain))
-      end
-
-      s(:block, name, params, hash, program, inverse_chain, open_strip, close_strip)
-    end
-
-    def process_inverse(expr)
-      _, block_params, statements, open_strip, close_strip = expr
-
-      block_params = process(block_params)
-      statements = process(statements)
-
-      case statements.sexp_type
-      when :statements
-        if (items = statements&.sexp_body)
-          strip_initial_whitespace(items.first, open_strip)
-          strip_final_whitespace(items.last, close_strip)
-        end
-      end
-      # TODO: Handle :block sexp_type
-
-      s(:inverse, block_params, statements, open_strip, close_strip)
-    end
-
-    def process_statements(expr)
-      statements = expr.sexp_body
-
-      statements.each_cons(2) do |prev, item|
-        strip_final_whitespace(prev, open_strip_for(item)) if item.sexp_type != :content
-        strip_initial_whitespace(item, close_strip_for(prev)) if prev.sexp_type != :content
-
-        strip_standalone_whitespace(prev, item.dig(4, 2, 1)) if item.sexp_type == :block
-        strip_standalone_whitespace(last_item(prev), item) if prev.sexp_type == :block
-      end
-      statements = statements.map { process(_1) }
-
-      s(:statements, *statements)
-    end
-
-    private
-
-    def first_item(container)
-      case container.sexp_type
-      when :statements
-        container.sexp_body.first
-      when :block
-        container.dig(4, 2, 1)
-      when :inverse
-        first_item container[2]
-      else
-        raise NotImplementedError
-      end
-    end
-
-    def last_item(container)
-      return if container.nil?
-
-      case container.sexp_type
-      when :block
-        last_item(container[5] || container[4])
-      when :statements
-        container.sexp_body.last
-      when :inverse, :program
-        last_item container[2]
-      when :content
-        container
-      else
-        raise NotImplementedError
-      end
-    end
-
-    def strip_initial_whitespace(item, strip)
-      item[1] = item[1].sub(/^\s*/, "") if item.sexp_type == :content && strip[2]
-    end
-
-    def strip_final_whitespace(item, strip)
-      item[1] = item[1].sub(/\s*$/, "") if item.sexp_type == :content && strip&.at(1)
-    end
-
-    def strip_standalone_whitespace(before, after)
-      return unless preceding_whitespace? before
-      return unless following_whitespace? after
-
-      clear_preceding_whitespace(before)
-      clear_following_whitespace(after)
-    end
-
-    def preceding_whitespace?(before)
-      before&.sexp_type == :content && before[1] =~ /\n\s*$/
-    end
-
-    def following_whitespace?(after)
-      after&.sexp_type == :content && after[1] =~ /^\s*\n/
-    end
-
-    # Strip trailing whitespace before but leave the \n
-    def clear_preceding_whitespace(before)
-      return if @ignore_standalone
-
-      before[1] = before[1].sub(/\n[ \t]+$/, "\n")
-    end
-
-    # Strip leading whitespace after including the \n
-    def clear_following_whitespace(after)
-      return if @ignore_standalone
-
-      after[1] = after[1].sub(/^[ \t]*\n/, "")
-    end
-
-    def open_strip_for(item)
-      case item.sexp_type
-      when :block
-        item.at(-2)
-      else
-        item.last
-      end
-    end
-
-    def close_strip_for(item)
-      item.last
-    end
-  end
-end