herb 0.9.3-arm-linux-gnu → 0.9.5-arm-linux-gnu

data/lib/herb/ast/nodes.rb

@@ -2128,6 +2128,7 @@ module Herb
     #|  tag_closing: Herb::Token?,
     #|  prism_node: String?,
     #|  body: Array[Herb::AST::Node],
+    #|  block_arguments: Array[Herb::AST::RubyParameterNode]?,
     #|  rescue_clause: Herb::AST::ERBRescueNode?,
     #|  else_clause: Herb::AST::ERBElseNode?,
     #|  ensure_clause: Herb::AST::ERBEnsureNode?,
@@ -2141,19 +2142,21 @@ module Herb
       attr_reader :tag_closing #: Herb::Token?
       attr_reader :prism_node #: String?
       attr_reader :body #: Array[Herb::AST::Node]
+      attr_reader :block_arguments #: Array[Herb::AST::RubyParameterNode]?
       attr_reader :rescue_clause #: Herb::AST::ERBRescueNode?
       attr_reader :else_clause #: Herb::AST::ERBElseNode?
       attr_reader :ensure_clause #: Herb::AST::ERBEnsureNode?
       attr_reader :end_node #: Herb::AST::ERBEndNode?
 
-      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
-      def initialize(type, location, errors, tag_opening, content, tag_closing, prism_node, body, rescue_clause, else_clause, ensure_clause, end_node)
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
+      def initialize(type, location, errors, tag_opening, content, tag_closing, prism_node, body, block_arguments, rescue_clause, else_clause, ensure_clause, end_node)
         super(type, location, errors)
         @tag_opening = tag_opening
         @content = content
         @tag_closing = tag_closing
         @prism_node = prism_node
         @body = body
+        @block_arguments = block_arguments
         @rescue_clause = rescue_clause
         @else_clause = else_clause
         @ensure_clause = ensure_clause
@@ -2184,6 +2187,7 @@ module Herb
           tag_closing: tag_closing,
           prism_node: prism_node,
           body: body,
+          block_arguments: block_arguments,
           rescue_clause: rescue_clause,
           else_clause: else_clause,
           ensure_clause: ensure_clause,
@@ -2198,7 +2202,7 @@ module Herb
 
       #: () -> Array[Herb::AST::Node?]
       def child_nodes
-        [*(body || []), rescue_clause, else_clause, ensure_clause, end_node]
+        [*(body || []), *(block_arguments || []), rescue_clause, else_clause, ensure_clause, end_node]
       end
 
       #: () -> Array[Herb::AST::Node]
@@ -2242,6 +2246,8 @@ module Herb
         end
         output += white("├── body: ")
         output += inspect_array(body, prefix: "│   ", indent: indent, depth: depth + 1, depth_limit: depth_limit)
+        output += white("├── block_arguments: ")
+        output += inspect_array(block_arguments, prefix: "│   ", indent: indent, depth: depth + 1, depth_limit: depth_limit)
         output += white("├── rescue_clause: ")
         if rescue_clause
           output += "\n"
@@ -3576,12 +3582,7 @@ module Herb
       end
     end
 
-    #: type serialized_erb_render_node = {
-    #|  tag_opening: Herb::Token?,
-    #|  content: Herb::Token?,
-    #|  tag_closing: Herb::Token?,
-    #|  analyzed_ruby: nil,
-    #|  prism_node: String?,
+    #: type serialized_ruby_render_keywords_node = {
     #|  partial: Herb::Token?,
     #|  template_path: Herb::Token?,
     #|  layout: Herb::Token?,
@@ -3601,14 +3602,9 @@ module Herb
     #|  content_type: Herb::Token?,
     #|  locals: Array[Herb::AST::RubyRenderLocalNode]?,
     #| }
-    class ERBRenderNode < Node
+    class RubyRenderKeywordsNode < Node
       include Colors
 
-      attr_reader :tag_opening #: Herb::Token?
-      attr_reader :content #: Herb::Token?
-      attr_reader :tag_closing #: Herb::Token?
-      attr_reader :analyzed_ruby #: nil
-      attr_reader :prism_node #: String?
       attr_reader :partial #: Herb::Token?
       attr_reader :template_path #: Herb::Token?
       attr_reader :layout #: Herb::Token?
@@ -3628,14 +3624,9 @@ module Herb
       attr_reader :content_type #: Herb::Token?
       attr_reader :locals #: Array[Herb::AST::RubyRenderLocalNode]?
 
-      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
-      def initialize(type, location, errors, tag_opening, content, tag_closing, analyzed_ruby, prism_node, partial, template_path, layout, file, inline_template, body, plain, html, renderable, collection, object, as_name, spacer_template, formats, variants, handlers, content_type, locals)
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+      def initialize(type, location, errors, partial, template_path, layout, file, inline_template, body, plain, html, renderable, collection, object, as_name, spacer_template, formats, variants, handlers, content_type, locals)
         super(type, location, errors)
-        @tag_opening = tag_opening
-        @content = content
-        @tag_closing = tag_closing
-        @analyzed_ruby = analyzed_ruby
-        @prism_node = prism_node
         @partial = partial
         @template_path = template_path
         @layout = layout
@@ -3656,30 +3647,9 @@ module Herb
         @locals = locals
       end
 
-      #: () -> Prism::node?
-      def deserialized_prism_node
-        prism_node = @prism_node
-        return nil unless prism_node
-        return nil unless source
-
-        begin
-          require "prism"
-        rescue LoadError
-          warn "The 'prism' gem is required to deserialize Prism nodes. Add it to your Gemfile or install it with: gem install prism"
-          return nil
-        end
-
-        Prism.load(source, prism_node).value
-      end
-
-      #: () -> serialized_erb_render_node
+      #: () -> serialized_ruby_render_keywords_node
       def to_hash
         super.merge({
-          tag_opening: tag_opening,
-          content: content,
-          tag_closing: tag_closing,
-          analyzed_ruby: analyzed_ruby,
-          prism_node: prism_node,
           partial: partial,
           template_path: template_path,
           layout: layout,
@@ -3698,12 +3668,12 @@ module Herb
           handlers: handlers,
           content_type: content_type,
           locals: locals,
-        }) #: Herb::serialized_erb_render_node
+        }) #: Herb::serialized_ruby_render_keywords_node
       end
 
       #: (Visitor) -> void
       def accept(visitor)
-        visitor.visit_erb_render_node(self)
+        visitor.visit_ruby_render_keywords_node(self)
       end
 
       #: () -> Array[Herb::AST::Node?]
@@ -3736,20 +3706,6 @@ module Herb
 
         output += inspect_errors(prefix: "│   ")
 
-        output += white("├── tag_opening: ")
-        output += tag_opening ? tag_opening.tree_inspect : magenta("∅")
-        output += "\n"
-        output += white("├── content: ")
-        output += content ? content.tree_inspect : magenta("∅")
-        output += "\n"
-        output += white("├── tag_closing: ")
-        output += tag_closing ? tag_closing.tree_inspect : magenta("∅")
-        output += "\n"
-        if prism_node && source
-          output += white("├── prism_node: ")
-          output += Herb::PrismInspect.inspect_prism_serialized(prism_node, source, "│   ")
-          output += "\n"
-        end
         output += white("├── partial: ")
         output += partial ? partial.tree_inspect : magenta("∅")
         output += "\n"
@@ -3809,42 +3765,222 @@ module Herb
       end
     end
 
-    #: type serialized_ruby_strict_local_node = {
+    #: type serialized_erb_render_node = {
+    #|  tag_opening: Herb::Token?,
+    #|  content: Herb::Token?,
+    #|  tag_closing: Herb::Token?,
+    #|  analyzed_ruby: nil,
+    #|  prism_node: String?,
+    #|  keywords: Herb::AST::RubyRenderKeywordsNode?,
+    #|  body: Array[Herb::AST::Node],
+    #|  block_arguments: Array[Herb::AST::RubyParameterNode]?,
+    #|  rescue_clause: Herb::AST::ERBRescueNode?,
+    #|  else_clause: Herb::AST::ERBElseNode?,
+    #|  ensure_clause: Herb::AST::ERBEnsureNode?,
+    #|  end_node: Herb::AST::ERBEndNode?,
+    #| }
+    class ERBRenderNode < Node
+      include Colors
+
+      attr_reader :tag_opening #: Herb::Token?
+      attr_reader :content #: Herb::Token?
+      attr_reader :tag_closing #: Herb::Token?
+      attr_reader :analyzed_ruby #: nil
+      attr_reader :prism_node #: String?
+      attr_reader :keywords #: Herb::AST::RubyRenderKeywordsNode?
+      attr_reader :body #: Array[Herb::AST::Node]
+      attr_reader :block_arguments #: Array[Herb::AST::RubyParameterNode]?
+      attr_reader :rescue_clause #: Herb::AST::ERBRescueNode?
+      attr_reader :else_clause #: Herb::AST::ERBElseNode?
+      attr_reader :ensure_clause #: Herb::AST::ERBEnsureNode?
+      attr_reader :end_node #: Herb::AST::ERBEndNode?
+
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::AST::RubyRenderKeywordsNode, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
+      def initialize(type, location, errors, tag_opening, content, tag_closing, analyzed_ruby, prism_node, keywords, body, block_arguments, rescue_clause, else_clause, ensure_clause, end_node)
+        super(type, location, errors)
+        @tag_opening = tag_opening
+        @content = content
+        @tag_closing = tag_closing
+        @analyzed_ruby = analyzed_ruby
+        @prism_node = prism_node
+        @keywords = keywords
+        @body = body
+        @block_arguments = block_arguments
+        @rescue_clause = rescue_clause
+        @else_clause = else_clause
+        @ensure_clause = ensure_clause
+        @end_node = end_node
+      end
+
+      #: () -> Prism::node?
+      def deserialized_prism_node
+        prism_node = @prism_node
+        return nil unless prism_node
+        return nil unless source
+
+        begin
+          require "prism"
+        rescue LoadError
+          warn "The 'prism' gem is required to deserialize Prism nodes. Add it to your Gemfile or install it with: gem install prism"
+          return nil
+        end
+
+        Prism.load(source, prism_node).value
+      end
+
+      #: () -> serialized_erb_render_node
+      def to_hash
+        super.merge({
+          tag_opening: tag_opening,
+          content: content,
+          tag_closing: tag_closing,
+          analyzed_ruby: analyzed_ruby,
+          prism_node: prism_node,
+          keywords: keywords,
+          body: body,
+          block_arguments: block_arguments,
+          rescue_clause: rescue_clause,
+          else_clause: else_clause,
+          ensure_clause: ensure_clause,
+          end_node: end_node,
+        }) #: Herb::serialized_erb_render_node
+      end
+
+      #: (Visitor) -> void
+      def accept(visitor)
+        visitor.visit_erb_render_node(self)
+      end
+
+      #: () -> Array[Herb::AST::Node?]
+      def child_nodes
+        [keywords, *(body || []), *(block_arguments || []), rescue_clause, else_clause, ensure_clause, end_node]
+      end
+
+      #: () -> Array[Herb::AST::Node]
+      def compact_child_nodes
+        child_nodes.compact
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 10)
+        output = +""
+
+        output += white("@ #{bold(yellow(node_name.to_s))} #{dimmed("(location: #{location.tree_inspect})")}")
+        output += "\n"
+
+        if depth >= depth_limit
+          output += dimmed("└── [depth limit reached ...]\n\n")
+
+          return output.gsub(/^/, "    " * indent)
+        end
+
+        output += inspect_errors(prefix: "│   ")
+
+        output += white("├── tag_opening: ")
+        output += tag_opening ? tag_opening.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── content: ")
+        output += content ? content.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── tag_closing: ")
+        output += tag_closing ? tag_closing.tree_inspect : magenta("∅")
+        output += "\n"
+        if prism_node && source
+          output += white("├── prism_node: ")
+          output += Herb::PrismInspect.inspect_prism_serialized(prism_node, source, "│   ")
+          output += "\n"
+        end
+        output += white("├── keywords: ")
+        if keywords
+          output += "\n"
+          output += "│   └── "
+          output += keywords.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "│   ").delete_prefix("│   ")
+        else
+          output += magenta("∅\n")
+        end
+        output += white("├── body: ")
+        output += inspect_array(body, prefix: "│   ", indent: indent, depth: depth + 1, depth_limit: depth_limit)
+        output += white("├── block_arguments: ")
+        output += inspect_array(block_arguments, prefix: "│   ", indent: indent, depth: depth + 1, depth_limit: depth_limit)
+        output += white("├── rescue_clause: ")
+        if rescue_clause
+          output += "\n"
+          output += "│   └── "
+          output += rescue_clause.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "│   ").delete_prefix("│   ")
+        else
+          output += magenta("∅\n")
+        end
+        output += white("├── else_clause: ")
+        if else_clause
+          output += "\n"
+          output += "│   └── "
+          output += else_clause.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "│   ").delete_prefix("│   ")
+        else
+          output += magenta("∅\n")
+        end
+        output += white("├── ensure_clause: ")
+        if ensure_clause
+          output += "\n"
+          output += "│   └── "
+          output += ensure_clause.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "│   ").delete_prefix("│   ")
+        else
+          output += magenta("∅\n")
+        end
+        output += white("└── end_node: ")
+        if end_node
+          output += "\n"
+          output += "    └── "
+          output += end_node.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "    ").delete_prefix("    ")
+        else
+          output += magenta("∅\n")
+        end
+        output += "\n"
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    #: type serialized_ruby_parameter_node = {
     #|  name: Herb::Token?,
     #|  default_value: Herb::AST::RubyLiteralNode?,
+    #|  kind: String?,
     #|  required: bool,
-    #|  double_splat: bool,
     #| }
-    class RubyStrictLocalNode < Node
+    class RubyParameterNode < Node
       include Colors
 
       attr_reader :name #: Herb::Token?
       attr_reader :default_value #: Herb::AST::RubyLiteralNode?
+      attr_reader :kind #: String?
       attr_reader :required #: bool
-      attr_reader :double_splat #: bool
 
-      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, bool, bool) -> void
-      def initialize(type, location, errors, name, default_value, required, double_splat)
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, String, bool) -> void
+      def initialize(type, location, errors, name, default_value, kind, required)
         super(type, location, errors)
         @name = name
         @default_value = default_value
+        @kind = kind&.force_encoding("utf-8")
         @required = required
-        @double_splat = double_splat
       end
 
-      #: () -> serialized_ruby_strict_local_node
+      #: () -> serialized_ruby_parameter_node
       def to_hash
         super.merge({
           name: name,
           default_value: default_value,
+          kind: kind,
           required: required,
-          double_splat: double_splat,
-        }) #: Herb::serialized_ruby_strict_local_node
+        }) #: Herb::serialized_ruby_parameter_node
       end
 
       #: (Visitor) -> void
       def accept(visitor)
-        visitor.visit_ruby_strict_local_node(self)
+        visitor.visit_ruby_parameter_node(self)
       end
 
       #: () -> Array[Herb::AST::Node?]
@@ -3888,12 +4024,10 @@ module Herb
         else
           output += magenta("∅\n")
         end
-        output += white("├── required: ")
+        output += white("├── kind: ") + green("#{kind.inspect}\n")
+        output += white("└── required: ")
         output += [true, false].include?(required) ? bold(magenta(required.to_s)) : magenta("∅")
         output += "\n"
-        output += white("└── double_splat: ")
-        output += [true, false].include?(double_splat) ? bold(magenta(double_splat.to_s)) : magenta("∅")
-        output += "\n"
         output += "\n"
 
         output.gsub(/^/, "    " * indent)
@@ -3906,7 +4040,7 @@ module Herb
     #|  tag_closing: Herb::Token?,
     #|  analyzed_ruby: nil,
     #|  prism_node: String?,
-    #|  locals: Array[Herb::AST::RubyStrictLocalNode]?,
+    #|  locals: Array[Herb::AST::RubyParameterNode]?,
     #| }
     class ERBStrictLocalsNode < Node
       include Colors
@@ -3916,9 +4050,9 @@ module Herb
       attr_reader :tag_closing #: Herb::Token?
       attr_reader :analyzed_ruby #: nil
       attr_reader :prism_node #: String?
-      attr_reader :locals #: Array[Herb::AST::RubyStrictLocalNode]?
+      attr_reader :locals #: Array[Herb::AST::RubyParameterNode]?
 
-      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyStrictLocalNode]) -> void
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyParameterNode]) -> void
       def initialize(type, location, errors, tag_opening, content, tag_closing, analyzed_ruby, prism_node, locals)
         super(type, location, errors)
         @tag_opening = tag_opening

data/lib/herb/engine/compiler.rb

@@ -5,6 +5,12 @@ module Herb
     class Compiler < ::Herb::Visitor
       EXPRESSION_TOKEN_TYPES = [:expr, :expr_escaped, :expr_block, :expr_block_escaped].freeze
 
+      TRAILING_WHITESPACE = /[ \t]+\z/
+      TRAILING_INDENTATION = /\n[ \t]+\z/
+      TRAILING_INDENTATION_CAPTURE = /\n([ \t]+)\z/
+      WHITESPACE_ONLY = /\A[ \t]+\z/
+      WHITESPACE_ONLY_CAPTURE = /\A([ \t]+)\z/
+
       attr_reader :tokens
 
       def initialize(engine, options = {})
@@ -93,11 +99,9 @@ module Herb
       def visit_html_attribute_value_node(node)
         push_context(:attribute_value)
 
-        add_text(node.open_quote&.value) if node.quoted
-
+        add_text(node.open_quote&.value || '"') if node.quoted
         visit_all(node.children)
-
-        add_text(node.close_quote&.value) if node.quoted
+        add_text(node.close_quote&.value || '"') if node.quoted
 
         pop_context
       end
@@ -150,9 +154,9 @@ module Herb
       end
 
       def visit_cdata_node(node)
-        add_text(node.cdata_opening.value)
+        add_text(node.tag_opening.value)
         visit_all(node.children)
-        add_text(node.cdata_closing.value)
+        add_text(node.tag_closing.value)
       end
 
       def visit_erb_content_node(node)
@@ -242,6 +246,8 @@ module Herb
       def visit_erb_block_node(node)
         opening = node.tag_opening.value
 
+        check_for_escaped_erb_tag!(opening)
+
         if opening.include?("=")
           should_escape = should_escape_output?(opening)
           code = node.content.value.strip
@@ -251,7 +257,9 @@ module Herb
                      else
                        [:expr_block, code, current_context]
                      end
+
           @last_trim_consumed_newline = false
+          @trim_next_whitespace = true if right_trim?(node)
 
           visit_all(node.body)
           visit_erb_block_end_node(node.end_node, escaped: should_escape)
@@ -267,9 +275,7 @@ module Herb
       end
 
       def visit_erb_block_end_node(node, escaped: false)
-        has_left_trim = node.tag_opening.value.start_with?("<%-")
-
-        remove_trailing_whitespace_from_last_token! if has_left_trim
+        remove_trailing_whitespace_from_last_token! if left_trim?(node)
 
         code = node.content.value.strip
 
@@ -302,6 +308,15 @@ module Herb
 
       private
 
+      def check_for_escaped_erb_tag!(opening)
+        return unless opening.start_with?("<%%")
+
+        raise Herb::Engine::GeneratorTemplateError,
+              "This file appears to be a generator template (a template used to generate ERB files) " \
+              "rather than a standard ERB template. It contains escaped ERB tags like <%%= %> which " \
+              "produce literal ERB output in the generated file."
+      end
+
       def current_context
         @context_stack.last
       end
@@ -336,10 +351,11 @@ module Herb
       def process_erb_tag(node, skip_comment_check: false)
         opening = node.tag_opening.value
 
+        check_for_escaped_erb_tag!(opening)
+
         if !skip_comment_check && erb_comment?(opening)
-          has_left_trim = opening.start_with?("<%-")
           follows_newline = leading_space_follows_newline?
-          remove_trailing_whitespace_from_last_token! if has_left_trim
+          remove_trailing_whitespace_from_last_token! if left_trim?(node)
 
           if at_line_start?
             leading_space = extract_and_remove_leading_space!
@@ -485,10 +501,9 @@ module Herb
           @last_trim_consumed_newline = false
         end
 
-        has_right_trim = node.tag_closing&.value == "-%>"
         should_escape = should_escape_output?(opening)
         add_expression_with_escaping(code, should_escape)
-        @trim_next_whitespace = true if has_right_trim
+        @trim_next_whitespace = true if right_trim?(node)
       end
 
       def indicator_for(type)
@@ -521,7 +536,7 @@ module Herb
         last_value = @tokens.last[1]
 
         if last_type == :text
-          last_value.empty? || last_value.end_with?("\n") || (last_value =~ /\A[ \t]+\z/ && preceding_token_ends_with_newline?) || last_value =~ /\n[ \t]+\z/
+          last_value.empty? || last_value.end_with?("\n") || (last_value =~ WHITESPACE_ONLY && preceding_token_ends_with_newline?) || last_value =~ TRAILING_INDENTATION
         elsif EXPRESSION_TOKEN_TYPES.include?(last_type)
           @last_trim_consumed_newline
         else
@@ -540,6 +555,14 @@ module Herb
         preceding[1].end_with?("\n")
       end
 
+      def left_trim?(node)
+        node.tag_opening.value == "<%-"
+      end
+
+      def right_trim?(node)
+        node.tag_closing&.value == "-%>"
+      end
+
       def last_text_token
         return unless @tokens.last && @tokens.last[0] == :text
 
@@ -552,7 +575,7 @@ module Herb
 
         text = token[1]
 
-        return Regexp.last_match(1) if text =~ /\n([ \t]+)\z/ || text =~ /\A([ \t]+)\z/
+        return Regexp.last_match(1) if text =~ TRAILING_INDENTATION_CAPTURE || text =~ WHITESPACE_ONLY_CAPTURE
 
         ""
       end
@@ -561,7 +584,12 @@ module Herb
         token = last_text_token
         return false unless token
 
-        token[1].match?(/\n[ \t]+\z/)
+        text = token[1]
+
+        return true if text.match?(TRAILING_INDENTATION)
+        return true if @last_trim_consumed_newline && text.match?(WHITESPACE_ONLY)
+
+        false
       end
 
       def extract_and_remove_leading_space!
@@ -570,9 +598,9 @@ module Herb
 
         text = @tokens.last[1]
 
-        if text =~ /\n[ \t]+\z/
-          text.sub!(/[ \t]+\z/, "")
-        elsif text =~ /\A[ \t]+\z/
+        if text =~ TRAILING_INDENTATION
+          text.sub!(TRAILING_WHITESPACE, "")
+        elsif text =~ WHITESPACE_ONLY
           text.replace("")
         end
 
@@ -582,10 +610,8 @@ module Herb
       end
 
       def apply_trim(node, code)
-        has_left_trim = node.tag_opening.value.start_with?("<%-")
-
         follows_newline = leading_space_follows_newline?
-        removed_whitespace = has_left_trim ? remove_trailing_whitespace_from_last_token! : ""
+        removed_whitespace = left_trim?(node) ? remove_trailing_whitespace_from_last_token! : ""
 
         if at_line_start?
           leading_space = extract_and_remove_leading_space!
@@ -617,12 +643,12 @@ module Herb
         return "" unless token
 
         text = token[1]
-        removed = text[/[ \t]+\z/] || ""
+        removed = text[TRAILING_WHITESPACE] || ""
 
-        if text =~ /\n[ \t]+\z/
-          text.sub!(/[ \t]+\z/, "")
+        if text =~ TRAILING_INDENTATION
+          text.sub!(TRAILING_WHITESPACE, "")
           token[1] = text
-        elsif text =~ /\A[ \t]+\z/
+        elsif text =~ WHITESPACE_ONLY
           text.replace("")
           token[1] = text
         end

data/lib/herb/engine.rb

@@ -31,6 +31,9 @@ module Herb
     class CompilationError < StandardError
     end
 
+    class GeneratorTemplateError < CompilationError
+    end
+
     class InvalidRubyError < CompilationError
       attr_reader :compiled_source