haparanda 0.0.1

data/lib/haparanda/whitespace_handler.rb

@@ -0,0 +1,168 @@
+# 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

data/lib/haparanda.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# All code in this gem lives in the Haparanda module
+module Haparanda
+  # Empty for now
+end
+
+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

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: haparanda
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matijs van Zuijlen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: sexp_processor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.17'
+description: |
+  Haparanda aims to be a fast implementation of all of Handlebars written in
+  Ruby. The lexer and parser track the upstream .l and .y files.
+email:
+- matijs@matijs.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- README.md
+files:
+- CHANGELOG.md
+- COPYING.LIB
+- README.md
+- 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/template.rb
+- lib/haparanda/version.rb
+- lib/haparanda/whitespace_handler.rb
+homepage: https://github.com/mvz/haparanda
+licenses:
+- LGPL-2.1-or-later
+metadata:
+  homepage_uri: https://github.com/mvz/haparanda
+  source_code_uri: https://github.com/mvz/haparanda
+  changelog_uri: https://github.com/mvz/haparanda/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Pure Ruby Handlebars Parser
+test_files: []