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

data/lib/herb/project.rb

@@ -71,9 +71,9 @@ module Herb
       attr_reader :successful, :failed, :timeout, :template_error, :unexpected_error,
                   :strict_parse_error, :analyze_parse_error,
                   :validation_error, :compilation_failed, :strict_compilation_failed,
-                  :invalid_ruby,
+                  :invalid_ruby, :skipped,
                   :error_outputs, :file_contents, :parse_errors, :compilation_errors,
-                  :file_diagnostics
+                  :file_diagnostics, :skip_reasons
 
       def initialize
         @successful = []
@@ -87,11 +87,13 @@ module Herb
         @compilation_failed = []
         @strict_compilation_failed = []
         @invalid_ruby = []
+        @skipped = []
         @error_outputs = {}
         @file_contents = {}
         @parse_errors = {}
         @compilation_errors = {}
         @file_diagnostics = {}
+        @skip_reasons = {}
       end
 
       def problem_files
@@ -432,8 +434,7 @@ module Herb
         nil
       end
 
-      { file_path: file_path, status: :timeout, file_content: file_content,
-        log: "⏱️ Parsing #{file_path} timed out after 1 second" }
+      { file_path: file_path, status: :timeout, file_content: file_content, log: "⏱️ Parsing #{file_path} timed out after 1 second" }
     rescue StandardError => e
       file_content ||= begin
         File.read(file_path)
@@ -441,8 +442,7 @@ module Herb
         nil
       end
 
-      { file_path: file_path, status: :failed, file_content: file_content,
-        log: "⚠️ Error processing #{file_path}: #{e.message}" }
+      { file_path: file_path, status: :failed, file_content: file_content, log: "⚠️ Error processing #{file_path}: #{e.message}" }
     ensure
       [stdout_file, stderr_file].each do |tempfile|
         next unless tempfile
@@ -488,6 +488,9 @@ module Herb
       Herb::Engine.new(file_content, filename: file_path, escape: true, validate_ruby: validate_ruby)
 
       { status: :successful, log: "✅ Compiled #{file_path} successfully" }
+    rescue Herb::Engine::GeneratorTemplateError => e
+      { status: :skipped, skip_reason: e.message,
+        log: "⊘ Skipping #{file_path}: #{e.message}" }
     rescue Herb::Engine::InvalidRubyError => e
       { status: :invalid_ruby, file_content: file_content,
         compilation_error: { error: e.message, backtrace: e.backtrace&.first(10) || [] },
@@ -545,6 +548,7 @@ module Herb
       tracker.parse_errors[file_path] = result[:parse_error] if result[:parse_error]
       tracker.compilation_errors[file_path] = result[:compilation_error] if result[:compilation_error]
       tracker.file_diagnostics[file_path] = result[:diagnostics] if result[:diagnostics]&.any?
+      tracker.skip_reasons[file_path] = result[:skip_reason] if result[:skip_reason]
     end
 
     def print_summary(results, log, duration)
@@ -563,13 +567,18 @@ module Herb
       puts "  #{label("Checked")} #{cyan("#{total} #{pluralize(total, "file")}")}"
 
       if total > 1
-        files_line = if issues.positive?
-                       "#{bold(green("#{passed} clean"))} | #{bold(red("#{issues} with issues"))}"
-                     else
-                       bold(green("#{total} clean"))
-                     end
+        files_parts = []
 
-        puts "  #{label("Files")} #{files_line}"
+        if issues.positive?
+          files_parts << bold(green("#{passed} clean"))
+          files_parts << bold(red("#{issues} with issues"))
+        else
+          files_parts << bold(green("#{total - results.skipped.count} clean"))
+        end
+
+        files_parts << dimmed("#{results.skipped.count} skipped") if results.skipped.any?
+
+        puts "  #{label("Files")} #{files_parts.join(" | ")}"
       end
 
       parser_parts = []
@@ -581,8 +590,9 @@ module Herb
       parser_parts << stat(results.analyze_parse_error.count, "analyze", :yellow) if results.analyze_parse_error.any?
       puts "  #{label("Parser")} #{parser_parts.join(" | ")}"
 
-      skipped = total - passed - results.validation_error.count - results.compilation_failed.count -
-                results.strict_compilation_failed.count - results.invalid_ruby.count
+      not_compiled = total - passed - results.skipped.count - results.validation_error.count -
+                     results.compilation_failed.count - results.strict_compilation_failed.count -
+                     results.invalid_ruby.count
 
       engine_parts = []
       engine_parts << stat(passed, "compiled", :green)
@@ -590,13 +600,17 @@ module Herb
       engine_parts << stat(results.compilation_failed.count, "compilation", :red) if results.compilation_failed.any?
       engine_parts << stat(results.strict_compilation_failed.count, "strict", :yellow) if results.strict_compilation_failed.any?
       engine_parts << stat(results.invalid_ruby.count, "produced invalid Ruby", :red) if results.invalid_ruby.any?
-      engine_parts << dimmed("#{skipped} skipped") if skipped.positive?
+      engine_parts << dimmed("#{not_compiled} not compiled") if not_compiled.positive?
       puts "  #{label("Engine")} #{engine_parts.join(" | ")}"
 
       if results.timeout.any?
         puts "  #{label("Timeout")} #{stat(results.timeout.count, "timed out", :yellow)}"
       end
 
+      if results.skipped.any?
+        puts "  #{label("Skipped")} #{dimmed("#{results.skipped.count} #{pluralize(results.skipped.count, "file")}")}"
+      end
+
       if duration
         puts "  #{label("Duration")} #{cyan(format_duration(duration))}"
       end
@@ -630,6 +644,7 @@ module Herb
       log.puts ""
       log.puts "--- Other ---"
       log.puts "⏱️ Timed out: #{results.timeout.count} (#{percentage(results.timeout.count, total)}%)"
+      log.puts "⊘ Skipped: #{results.skipped.count} (#{percentage(results.skipped.count, total)}%)"
 
       return unless duration
 
@@ -639,10 +654,27 @@ module Herb
     def print_file_lists(results, log)
       log_file_lists(results, log)
 
-      return unless results.problem_files.any?
-
       printed_section = false
 
+      if results.skipped.any?
+        printed_section = true
+
+        puts "\n"
+        puts " #{bold("Skipped files:")}"
+        puts " #{dimmed("These files were parsed successfully but skipped for compilation by the engine.")}"
+
+        results.skipped.each do |file|
+          relative = relative_path(file)
+          reason = results.skip_reasons[file]
+
+          puts ""
+          puts " #{cyan(relative)}:"
+          puts "   #{dimmed("⊘")} #{dimmed(reason)}"
+        end
+      end
+
+      return unless results.problem_files.any?
+
       ISSUE_TYPES.each do |type|
         file_list = results.send(type[:key])
         next unless file_list.any?
@@ -682,6 +714,15 @@ module Herb
     end
 
     def log_file_lists(results, log)
+      if results.skipped.any?
+        log.puts "\n#{heading("Files: Skipped")}"
+
+        results.skipped.each do |file|
+          reason = results.skip_reasons[file]
+          log.puts "#{file} - #{reason}"
+        end
+      end
+
       ISSUE_TYPES.each do |type|
         file_list = results.send(type[:key])
         next unless file_list.any?

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.9.3"
+  VERSION = "0.9.5"
 end

data/lib/herb/visitor.rb

@@ -271,6 +271,12 @@ module Herb
       visit_child_nodes(node)
     end
 
+    #: (Herb::AST::RubyRenderKeywordsNode) -> void
+    def visit_ruby_render_keywords_node(node)
+      visit_node(node)
+      visit_child_nodes(node)
+    end
+
     #: (Herb::AST::ERBRenderNode) -> void
     def visit_erb_render_node(node)
       visit_node(node)
@@ -278,8 +284,8 @@ module Herb
       visit_child_nodes(node)
     end
 
-    #: (Herb::AST::RubyStrictLocalNode) -> void
-    def visit_ruby_strict_local_node(node)
+    #: (Herb::AST::RubyParameterNode) -> void
+    def visit_ruby_parameter_node(node)
       visit_node(node)
       visit_child_nodes(node)
     end

data/sig/herb/ast/nodes.rbs

@@ -944,6 +944,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?,
@@ -962,6 +963,8 @@ module Herb
 
       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?
@@ -970,8 +973,8 @@ module Herb
 
       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: (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
+      # : (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: (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
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?
@@ -1514,12 +1517,7 @@ module Herb
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     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?,
@@ -1539,19 +1537,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?
@@ -1588,8 +1576,71 @@ module Herb
 
       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: (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
+      # : (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: (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
+
+      # : () -> serialized_ruby_render_keywords_node
+      def to_hash: () -> serialized_ruby_render_keywords_node
+
+      # : (Visitor) -> void
+      def accept: (Visitor) -> void
+
+      # : () -> Array[Herb::AST::Node?]
+      def child_nodes: () -> Array[Herb::AST::Node?]
+
+      # : () -> Array[Herb::AST::Node]
+      def compact_child_nodes: () -> Array[Herb::AST::Node]
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    # : 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: (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
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?
@@ -1613,28 +1664,28 @@ module Herb
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
 
-    # : type serialized_ruby_strict_local_node = {
+    # : 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 required: bool
+      attr_reader kind: String?
 
-      attr_reader double_splat: bool
+      attr_reader required: bool
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, bool, bool) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, bool, bool) -> void
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, String, bool) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, String, bool) -> void
 
-      # : () -> serialized_ruby_strict_local_node
-      def to_hash: () -> serialized_ruby_strict_local_node
+      # : () -> serialized_ruby_parameter_node
+      def to_hash: () -> serialized_ruby_parameter_node
 
       # : (Visitor) -> void
       def accept: (Visitor) -> void
@@ -1658,7 +1709,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
@@ -1673,10 +1724,10 @@ module Herb
 
       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
-      def initialize: (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: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyParameterNode]) -> void
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?

data/sig/herb/engine/compiler.rbs

@@ -5,6 +5,16 @@ module Herb
     class Compiler < ::Herb::Visitor
       EXPRESSION_TOKEN_TYPES: untyped
 
+      TRAILING_WHITESPACE: ::Regexp
+
+      TRAILING_INDENTATION: ::Regexp
+
+      TRAILING_INDENTATION_CAPTURE: ::Regexp
+
+      WHITESPACE_ONLY: ::Regexp
+
+      WHITESPACE_ONLY_CAPTURE: ::Regexp
+
       attr_reader tokens: untyped
 
       def initialize: (untyped engine, ?untyped options) -> untyped
@@ -85,6 +95,8 @@ module Herb
 
       private
 
+      def check_for_escaped_erb_tag!: (untyped opening) -> untyped
+
       def current_context: () -> untyped
 
       def push_context: (untyped context) -> untyped
@@ -134,6 +146,10 @@ module Herb
 
       def preceding_token_ends_with_newline?: () -> untyped
 
+      def left_trim?: (untyped node) -> untyped
+
+      def right_trim?: (untyped node) -> untyped
+
       def last_text_token: () -> untyped
 
       def extract_leading_space: () -> untyped

data/sig/herb/engine.rbs

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

data/sig/herb/visitor.rbs

@@ -130,11 +130,14 @@ module Herb
     # : (Herb::AST::RubyRenderLocalNode) -> void
     def visit_ruby_render_local_node: (Herb::AST::RubyRenderLocalNode) -> void
 
+    # : (Herb::AST::RubyRenderKeywordsNode) -> void
+    def visit_ruby_render_keywords_node: (Herb::AST::RubyRenderKeywordsNode) -> void
+
     # : (Herb::AST::ERBRenderNode) -> void
     def visit_erb_render_node: (Herb::AST::ERBRenderNode) -> void
 
-    # : (Herb::AST::RubyStrictLocalNode) -> void
-    def visit_ruby_strict_local_node: (Herb::AST::RubyStrictLocalNode) -> void
+    # : (Herb::AST::RubyParameterNode) -> void
+    def visit_ruby_parameter_node: (Herb::AST::RubyParameterNode) -> void
 
     # : (Herb::AST::ERBStrictLocalsNode) -> void
     def visit_erb_strict_locals_node: (Herb::AST::ERBStrictLocalsNode) -> void

data/sig/serialized_ast_nodes.rbs

@@ -170,6 +170,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,
@@ -276,12 +277,7 @@ module Herb
     value: Herb::AST::RubyLiteralNode,
   }
 
-  type serialized_erb_render_node = serialized_node & {
-    tag_opening: Herb::Token,
-    content: Herb::Token,
-    tag_closing: Herb::Token,
-    analyzed_ruby: nil,
-    prism_node: String,
+  type serialized_ruby_render_keywords_node = serialized_node & {
     partial: Herb::Token,
     template_path: Herb::Token,
     layout: Herb::Token,
@@ -302,11 +298,26 @@ module Herb
     locals: Array[Herb::AST::RubyRenderLocalNode],
   }
 
-  type serialized_ruby_strict_local_node = serialized_node & {
+  type serialized_erb_render_node = serialized_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,
+  }
+
+  type serialized_ruby_parameter_node = serialized_node & {
     name: Herb::Token,
     default_value: Herb::AST::RubyLiteralNode,
+    kind: String,
     required: bool,
-    double_splat: bool,
   }
 
   type serialized_erb_strict_locals_node = serialized_node & {
@@ -315,7 +326,7 @@ module Herb
     tag_closing: Herb::Token,
     analyzed_ruby: nil,
     prism_node: String,
-    locals: Array[Herb::AST::RubyStrictLocalNode],
+    locals: Array[Herb::AST::RubyParameterNode],
   }
 
   type serialized_erb_yield_node = serialized_node & {

data/src/analyze/action_view/javascript_tag.c

@@ -1,4 +1,9 @@
 #include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/ast/ast_nodes.h"
+#include "../../include/lib/hb_array.h"
+#include "../../include/lib/hb_string.h"
+#include "../../include/visitor.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -45,6 +50,39 @@ bool javascript_tag_supports_block(void) {
   return true;
 }
 
+bool wrap_javascript_tag_body_visitor(const AST_NODE_T* node, void* data) {
+  hb_allocator_T* allocator = (hb_allocator_T*) data;
+
+  if (node == NULL || node->type != AST_HTML_ELEMENT_NODE) { return true; }
+
+  AST_HTML_ELEMENT_NODE_T* element = (AST_HTML_ELEMENT_NODE_T*) node;
+
+  if (!hb_string_equals(element->element_source, hb_string("ActionView::Helpers::JavaScriptHelper#javascript_tag"))) {
+    return true;
+  }
+
+  if (element->body == NULL || hb_array_size(element->body) == 0) { return false; }
+
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    AST_NODE_T* child = (AST_NODE_T*) hb_array_get(element->body, i);
+    if (child && child->type == AST_CDATA_NODE) { return false; }
+  }
+
+  hb_array_T* cdata_children = hb_array_init(hb_array_size(element->body), allocator);
+
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    hb_array_append(cdata_children, hb_array_get(element->body, i));
+  }
+
+  AST_CDATA_NODE_T* cdata_node =
+    create_javascript_cdata_node(cdata_children, element->base.location.start, element->base.location.end, allocator);
+
+  element->body->size = 0;
+  hb_array_append(element->body, (AST_NODE_T*) cdata_node);
+
+  return false;
+}
+
 const tag_helper_handler_T javascript_tag_handler = {
   .name = "javascript_tag",
   .source = HB_STRING_LITERAL("ActionView::Helpers::JavaScriptHelper#javascript_tag"),

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -124,7 +124,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node_precise(
       open_quote,
       value_children,
       close_quote,
-      positions->quoted,
+      true,
       positions->value_start,
       positions->value_end,
       hb_array_init(0, allocator),
@@ -179,7 +179,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
     NULL,
     value_children,
     NULL,
-    false,
+    true,
     positions->content_start,
     positions->content_end,
     hb_array_init(0, allocator),
@@ -385,3 +385,24 @@ void append_body_content_node(
     if (text_node) { hb_array_append(body, (AST_NODE_T*) text_node); }
   }
 }
+
+AST_CDATA_NODE_T* create_javascript_cdata_node(
+  hb_array_T* children,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  token_T* cdata_opening = create_synthetic_token(allocator, "\n//<![CDATA[\n", TOKEN_CDATA_START, start, end);
+
+  token_T* cdata_closing = create_synthetic_token(allocator, "\n//]]>\n", TOKEN_CDATA_END, start, end);
+
+  return ast_cdata_node_init(
+    cdata_opening,
+    children,
+    cdata_closing,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}