herb 0.9.2-x86_64-linux-gnu → 0.9.3-x86_64-linux-gnu

data/lib/herb/ast/nodes.rb

@@ -2128,6 +2128,9 @@ module Herb
     #|  tag_closing: Herb::Token?,
     #|  prism_node: String?,
     #|  body: Array[Herb::AST::Node],
+    #|  rescue_clause: Herb::AST::ERBRescueNode?,
+    #|  else_clause: Herb::AST::ERBElseNode?,
+    #|  ensure_clause: Herb::AST::ERBEnsureNode?,
     #|  end_node: Herb::AST::ERBEndNode?,
     #| }
     class ERBBlockNode < Node
@@ -2138,16 +2141,22 @@ module Herb
       attr_reader :tag_closing #: Herb::Token?
       attr_reader :prism_node #: String?
       attr_reader :body #: Array[Herb::AST::Node]
+      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::ERBEndNode) -> void
-      def initialize(type, location, errors, tag_opening, content, tag_closing, prism_node, body, end_node)
+      #: (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)
         super(type, location, errors)
         @tag_opening = tag_opening
         @content = content
         @tag_closing = tag_closing
         @prism_node = prism_node
         @body = body
+        @rescue_clause = rescue_clause
+        @else_clause = else_clause
+        @ensure_clause = ensure_clause
         @end_node = end_node
       end
 
@@ -2175,6 +2184,9 @@ module Herb
           tag_closing: tag_closing,
           prism_node: prism_node,
           body: body,
+          rescue_clause: rescue_clause,
+          else_clause: else_clause,
+          ensure_clause: ensure_clause,
           end_node: end_node,
         }) #: Herb::serialized_erb_block_node
       end
@@ -2186,7 +2198,7 @@ module Herb
 
       #: () -> Array[Herb::AST::Node?]
       def child_nodes
-        [*(body || []), end_node]
+        [*(body || []), rescue_clause, else_clause, ensure_clause, end_node]
       end
 
       #: () -> Array[Herb::AST::Node]
@@ -2230,6 +2242,30 @@ module Herb
         end
         output += white("├── body: ")
         output += inspect_array(body, 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"
@@ -3773,6 +3809,211 @@ module Herb
       end
     end
 
+    #: type serialized_ruby_strict_local_node = {
+    #|  name: Herb::Token?,
+    #|  default_value: Herb::AST::RubyLiteralNode?,
+    #|  required: bool,
+    #|  double_splat: bool,
+    #| }
+    class RubyStrictLocalNode < Node
+      include Colors
+
+      attr_reader :name #: Herb::Token?
+      attr_reader :default_value #: Herb::AST::RubyLiteralNode?
+      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)
+        super(type, location, errors)
+        @name = name
+        @default_value = default_value
+        @required = required
+        @double_splat = double_splat
+      end
+
+      #: () -> serialized_ruby_strict_local_node
+      def to_hash
+        super.merge({
+          name: name,
+          default_value: default_value,
+          required: required,
+          double_splat: double_splat,
+        }) #: Herb::serialized_ruby_strict_local_node
+      end
+
+      #: (Visitor) -> void
+      def accept(visitor)
+        visitor.visit_ruby_strict_local_node(self)
+      end
+
+      #: () -> Array[Herb::AST::Node?]
+      def child_nodes
+        [default_value]
+      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("├── name: ")
+        output += name ? name.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── default_value: ")
+        if default_value
+          output += "\n"
+          output += "│   └── "
+          output += default_value.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("├── 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)
+      end
+    end
+
+    #: type serialized_erb_strict_locals_node = {
+    #|  tag_opening: Herb::Token?,
+    #|  content: Herb::Token?,
+    #|  tag_closing: Herb::Token?,
+    #|  analyzed_ruby: nil,
+    #|  prism_node: String?,
+    #|  locals: Array[Herb::AST::RubyStrictLocalNode]?,
+    #| }
+    class ERBStrictLocalsNode < 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 :locals #: Array[Herb::AST::RubyStrictLocalNode]?
+
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyStrictLocalNode]) -> void
+      def initialize(type, location, errors, tag_opening, content, tag_closing, analyzed_ruby, prism_node, locals)
+        super(type, location, errors)
+        @tag_opening = tag_opening
+        @content = content
+        @tag_closing = tag_closing
+        @analyzed_ruby = analyzed_ruby
+        @prism_node = prism_node
+        @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_strict_locals_node
+      def to_hash
+        super.merge({
+          tag_opening: tag_opening,
+          content: content,
+          tag_closing: tag_closing,
+          analyzed_ruby: analyzed_ruby,
+          prism_node: prism_node,
+          locals: locals,
+        }) #: Herb::serialized_erb_strict_locals_node
+      end
+
+      #: (Visitor) -> void
+      def accept(visitor)
+        visitor.visit_erb_strict_locals_node(self)
+      end
+
+      #: () -> Array[Herb::AST::Node?]
+      def child_nodes
+        [*(locals || [])]
+      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("└── locals: ")
+        output += inspect_array(locals, prefix: "    ", indent: indent, depth: depth + 1, depth_limit: depth_limit)
+        output += "\n"
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
     #: type serialized_erb_yield_node = {
     #|  tag_opening: Herb::Token?,
     #|  content: Herb::Token?,

data/lib/herb/cli.rb

@@ -8,7 +8,7 @@ require "optparse"
 class Herb::CLI
   include Herb::Colors
 
-  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check
+  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check, :action_view_helpers, :trim
 
   def initialize(args)
     @args = args
@@ -160,7 +160,7 @@ class Herb::CLI
                   show_config
                   exit(0)
                 when "parse"
-                  Herb.parse(file_content, strict: strict.nil? || strict, analyze: analyze.nil? || analyze, track_whitespace: track_whitespace || false, arena_stats: arena_stats)
+                  Herb.parse(file_content, strict: strict.nil? || strict, analyze: analyze.nil? || analyze, track_whitespace: track_whitespace || false, arena_stats: arena_stats, action_view_helpers: action_view_helpers || false)
                 when "compile"
                   compile_template
                 when "render"
@@ -298,6 +298,14 @@ class Herb::CLI
         self.track_whitespace = true
       end
 
+      parser.on("--action-view-helpers", "Enable Action View helper detection (for parse command) (default: false)") do
+        self.action_view_helpers = true
+      end
+
+      parser.on("--trim", "Enable trimming of leading/trailing whitespace (for compile/render commands)") do
+        self.trim = true
+      end
+
       parser.on("--tool TOOL", "Show config for specific tool: linter, formatter (for config command)") do |t|
         self.tool = t.to_sym
       end
@@ -442,6 +450,7 @@ class Herb::CLI
         options[:debug_filename] = @file if @file
       end
 
+      options[:trim] = true if trim
       options[:validate_ruby] = true
       engine = Herb::Engine.new(file_content, options)
 
@@ -529,6 +538,7 @@ class Herb::CLI
         options[:debug_filename] = @file if @file
       end
 
+      options[:trim] = true if trim
       engine = Herb::Engine.new(file_content, options)
       compiled_code = engine.src
 

data/lib/herb/engine/compiler.rb

@@ -3,6 +3,8 @@
 module Herb
   class Engine
     class Compiler < ::Herb::Visitor
+      EXPRESSION_TOKEN_TYPES = [:expr, :expr_escaped, :expr_block, :expr_block_escaped].freeze
+
       attr_reader :tokens
 
       def initialize(engine, options = {})
@@ -14,6 +16,9 @@ module Herb
         @element_stack = [] #: Array[String]
         @context_stack = [:html_content]
         @trim_next_whitespace = false
+        @last_trim_consumed_newline = false
+        @pending_leading_whitespace = nil
+        @pending_leading_whitespace_insert_index = 0
       end
 
       def generate_output
@@ -46,43 +51,19 @@ module Herb
       end
 
       def visit_html_element_node(node)
-        tag_name = node.tag_name&.value&.downcase
-
-        @element_stack.push(tag_name) if tag_name
-
-        if tag_name == "script"
-          push_context(:script_content)
-        elsif tag_name == "style"
-          push_context(:style_content)
+        with_element_context(node) do
+          visit(node.open_tag)
+          visit_all(node.body)
+          visit(node.close_tag)
         end
-
-        visit(node.open_tag)
-        visit_all(node.body)
-        visit(node.close_tag)
-
-        pop_context if ["script", "style"].include?(tag_name)
-
-        @element_stack.pop if tag_name
       end
 
       def visit_html_conditional_element_node(node)
-        tag_name = node.tag_name&.value&.downcase
-
-        @element_stack.push(tag_name) if tag_name
-
-        if tag_name == "script"
-          push_context(:script_content)
-        elsif tag_name == "style"
-          push_context(:style_content)
+        with_element_context(node) do
+          visit(node.open_conditional)
+          visit_all(node.body)
+          visit(node.close_conditional)
         end
-
-        visit(node.open_conditional)
-        visit_all(node.body)
-        visit(node.close_conditional)
-
-        pop_context if ["script", "style"].include?(tag_name)
-
-        @element_stack.pop if tag_name
       end
 
       def visit_html_open_tag_node(node)
@@ -270,12 +251,16 @@ module Herb
                      else
                        [:expr_block, code, current_context]
                      end
+          @last_trim_consumed_newline = false
 
           visit_all(node.body)
           visit_erb_block_end_node(node.end_node, escaped: should_escape)
         else
           visit_erb_control_node(node) do
             visit_all(node.body)
+            visit(node.rescue_clause)
+            visit(node.else_clause)
+            visit(node.ensure_clause)
             visit(node.end_node)
           end
         end
@@ -289,10 +274,10 @@ module Herb
         code = node.content.value.strip
 
         if at_line_start?
-          lspace = extract_and_remove_lspace!
-          rspace = " \n"
+          leading_space = extract_and_remove_leading_space!
+          right_space = " \n"
 
-          @tokens << [:expr_block_end, "#{lspace}#{code}#{rspace}", current_context, escaped]
+          @tokens << [:expr_block_end, "#{leading_space}#{code}#{right_space}", current_context, escaped]
           @trim_next_whitespace = true
         else
           @tokens << [:expr_block_end, code, current_context, escaped]
@@ -329,16 +314,37 @@ module Herb
         @context_stack.pop
       end
 
+      #: (untyped node) { () -> untyped } -> untyped
+      def with_element_context(node)
+        tag_name = node.tag_name&.value&.downcase
+
+        @element_stack.push(tag_name) if tag_name
+
+        if tag_name == "script"
+          push_context(:script_content)
+        elsif tag_name == "style"
+          push_context(:style_content)
+        end
+
+        yield
+
+        pop_context if ["script", "style"].include?(tag_name)
+
+        @element_stack.pop if tag_name
+      end
+
       def process_erb_tag(node, skip_comment_check: false)
         opening = node.tag_opening.value
 
         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
 
           if at_line_start?
-            extract_and_remove_lspace!
+            leading_space = extract_and_remove_leading_space!
             @trim_next_whitespace = true
+            save_pending_leading_whitespace!(leading_space) if !leading_space.empty? && follows_newline
           end
           return
         end
@@ -357,10 +363,17 @@ module Herb
         return if text.empty?
 
         if @trim_next_whitespace
+          @last_trim_consumed_newline = text.match?(/\A[ \t]*\r?\n/)
           text = text.sub(/\A[ \t]*\r?\n/, "")
           @trim_next_whitespace = false
+
+          restore_pending_leading_whitespace! unless @last_trim_consumed_newline
+        else
+          @last_trim_consumed_newline = false
         end
 
+        @pending_leading_whitespace = nil
+
         return if text.empty?
 
         @tokens << [:text, text, current_context]
@@ -376,10 +389,12 @@ module Herb
 
       def add_expression(code)
         @tokens << [:expr, code, current_context]
+        @last_trim_consumed_newline = false
       end
 
       def add_expression_escaped(code)
         @tokens << [:expr_escaped, code, current_context]
+        @last_trim_consumed_newline = false
       end
 
       def optimize_tokens(tokens)
@@ -463,6 +478,13 @@ module Herb
       end
 
       def process_erb_output(node, opening, code)
+        if @trim_next_whitespace && @pending_leading_whitespace
+          restore_pending_leading_whitespace!
+          @pending_leading_whitespace = nil
+          @trim_next_whitespace = false
+          @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)
@@ -493,78 +515,119 @@ module Herb
       end
 
       def at_line_start?
-        @tokens.empty? ||
-          @tokens.last[0] != :text ||
-          @tokens.last[1].empty? ||
-          @tokens.last[1].end_with?("\n") ||
-          (@tokens.last[1] =~ /\A[ \t]+\z/ && preceding_token_ends_with_newline?) ||
-          @tokens.last[1] =~ /\n[ \t]+\z/
+        return true if @tokens.empty?
+
+        last_type = @tokens.last[0]
+        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/
+        elsif EXPRESSION_TOKEN_TYPES.include?(last_type)
+          @last_trim_consumed_newline
+        else
+          last_value.end_with?("\n")
+        end
       end
 
       def preceding_token_ends_with_newline?
         return true unless @tokens.length >= 2
 
         preceding = @tokens[-2]
-        return false if [:expr, :expr_escaped, :expr_block, :expr_block_escaped, :expr_block_end].include?(preceding[0])
+        return @last_trim_consumed_newline if EXPRESSION_TOKEN_TYPES.include?(preceding[0])
+        return preceding[1].end_with?("\n") if preceding[0] == :expr_block_end
         return true unless preceding[0] == :text
 
         preceding[1].end_with?("\n")
       end
 
-      def extract_lspace
-        return "" unless @tokens.last && @tokens.last[0] == :text
+      def last_text_token
+        return unless @tokens.last && @tokens.last[0] == :text
 
-        text = @tokens.last[1]
+        @tokens.last
+      end
+
+      def extract_leading_space
+        token = last_text_token
+        return "" unless token
+
+        text = token[1]
 
         return Regexp.last_match(1) if text =~ /\n([ \t]+)\z/ || text =~ /\A([ \t]+)\z/
 
         ""
       end
 
-      def extract_and_remove_lspace!
-        lspace = extract_lspace
-        return lspace if lspace.empty?
+      def leading_space_follows_newline?
+        token = last_text_token
+        return false unless token
+
+        token[1].match?(/\n[ \t]+\z/)
+      end
+
+      def extract_and_remove_leading_space!
+        leading_space = extract_leading_space
+        return leading_space if leading_space.empty?
 
         text = @tokens.last[1]
+
         if text =~ /\n[ \t]+\z/
           text.sub!(/[ \t]+\z/, "")
         elsif text =~ /\A[ \t]+\z/
           text.replace("")
         end
+
         @tokens.last[1] = text
 
-        lspace
+        leading_space
       end
 
       def apply_trim(node, code)
         has_left_trim = node.tag_opening.value.start_with?("<%-")
-        node.tag_closing&.value
 
-        remove_trailing_whitespace_from_last_token! if has_left_trim
+        follows_newline = leading_space_follows_newline?
+        removed_whitespace = has_left_trim ? remove_trailing_whitespace_from_last_token! : ""
 
         if at_line_start?
-          lspace = extract_and_remove_lspace!
-          rspace = Herb::Engine.heredoc?(code) ? "\n" : " \n"
+          leading_space = extract_and_remove_leading_space!
+          effective_leading_space = leading_space.empty? ? removed_whitespace : leading_space
+          right_space = Herb::Engine.heredoc?(code) ? "\n" : " \n"
 
-          @tokens << [:code, "#{lspace}#{code}#{rspace}", current_context]
+          @pending_leading_whitespace_insert_index = @tokens.length
+          @pending_leading_whitespace = effective_leading_space if !effective_leading_space.empty? && follows_newline
+          @tokens << [:code, "#{effective_leading_space}#{code}#{right_space}", current_context]
           @trim_next_whitespace = true
         else
           @tokens << [:code, code, current_context]
         end
       end
 
+      def save_pending_leading_whitespace!(whitespace)
+        @pending_leading_whitespace = whitespace
+        @pending_leading_whitespace_insert_index = @tokens.length
+      end
+
+      def restore_pending_leading_whitespace!
+        return unless @pending_leading_whitespace
+
+        @tokens.insert(@pending_leading_whitespace_insert_index, [:text, @pending_leading_whitespace, current_context])
+      end
+
       def remove_trailing_whitespace_from_last_token!
-        return unless @tokens.last && @tokens.last[0] == :text
+        token = last_text_token
+        return "" unless token
 
-        text = @tokens.last[1]
+        text = token[1]
+        removed = text[/[ \t]+\z/] || ""
 
         if text =~ /\n[ \t]+\z/
           text.sub!(/[ \t]+\z/, "")
-          @tokens.last[1] = text
+          token[1] = text
         elsif text =~ /\A[ \t]+\z/
           text.replace("")
-          @tokens.last[1] = text
+          token[1] = text
         end
+
+        removed
       end
     end
   end