herb 0.9.1-aarch64-linux-gnu → 0.9.3-aarch64-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