herb 0.11.0-x86_64-linux-gnu → 0.11.2-x86_64-linux-gnu

data/lib/herb/ast/nodes.rb

@@ -4964,6 +4964,7 @@ module Herb
     #|  tag_opening: Herb::Token?,
     #|  content: Herb::Token?,
     #|  tag_closing: Herb::Token?,
+    #|  prism_node: String?,
     #| }
     class ERBYieldNode < Node
       include Colors
@@ -4971,13 +4972,15 @@ module Herb
       attr_reader :tag_opening #: Herb::Token?
       attr_reader :content #: Herb::Token?
       attr_reader :tag_closing #: Herb::Token?
+      attr_reader :prism_node #: String?
 
-      #: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?) -> void
-      def initialize(type, location, errors, tag_opening, content, tag_closing)
+      #: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?, String?) -> void
+      def initialize(type, location, errors, tag_opening, content, tag_closing, prism_node)
         super(type, location, errors)
         @tag_opening = tag_opening
         @content = content
         @tag_closing = tag_closing
+        @prism_node = prism_node
       end
 
       #: () -> String
@@ -4985,9 +4988,25 @@ module Herb
         "AST_ERB_YIELD_NODE"
       end
 
-      #: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
-      def self.build(tag_opening: nil, content: nil, tag_closing: nil, location: Location.zero, errors: [])
-        new(type, location, errors, tag_opening, content, tag_closing)
+      #: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?prism_node: String?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+      def self.build(tag_opening: nil, content: nil, tag_closing: nil, prism_node: nil, location: Location.zero, errors: [])
+        new(type, location, errors, tag_opening, content, tag_closing, prism_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_yield_node
@@ -4996,6 +5015,7 @@ module Herb
           tag_opening: tag_opening,
           content: content,
           tag_closing: tag_closing,
+          prism_node: prism_node,
         }) #: Herb::serialized_erb_yield_node
       end
 
@@ -5042,9 +5062,15 @@ module Herb
         output += white("├── content: ")
         output += content ? content.tree_inspect : magenta("∅")
         output += "\n"
-        output += white("└── tag_closing: ")
+        dynamic_symbol = prism_node ? "├──" : "└──"
+        output += white("#{dynamic_symbol} 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 += "\n"
 
         output.gsub(/^/, "    " * indent)

data/lib/herb/bootstrap.rb

@@ -70,13 +70,17 @@ module Herb
       bundler_gems_dir = File.expand_path("..", ROOT_PATH)
       candidates = Dir.glob(File.join(bundler_gems_dir, "prism-*"))
 
-      candidates.find { |path| File.directory?(File.join(path, "src")) }
+      candidates.find { |path| prism_source?(path) }
+    end
+
+    def self.prism_source?(path)
+      File.directory?(File.join(path, "src")) && File.exist?(File.join(path, "config.yml"))
     end
 
     def self.find_prism_from_gem_spec
       Gem::Specification.find_all_by_name("prism")
                         .map(&:full_gem_path)
-                        .find { |path| File.directory?(File.join(path, "src")) }
+                        .find { |path| prism_source?(path) }
     end
   end
 end

data/lib/herb/configuration.rb

@@ -100,11 +100,21 @@ module Herb
       parser["erb_openers"] || []
     end
 
+    #: () -> String?
+    def ruby_version
+      parser["ruby_version"]
+    end
+
     #: () -> Hash[Symbol, untyped]
     def parser_options
+      options = {} #: Hash[Symbol, untyped]
       openers = erb_openers
+      version = ruby_version
+
+      options[:erb_openers] = openers unless openers.empty?
+      options[:ruby_version] = version if version
 
-      openers.empty? ? {} : { erb_openers: openers }
+      options
     end
 
     def linter

data/lib/herb/dev/classifier.rb

@@ -61,7 +61,7 @@ module Herb
 
         return classification(:whitespace, operations: operations) if significant.empty?
 
-        kind = self.class.can_patch?(significant) && @parser_options.empty? ? :static : :dynamic
+        kind = self.class.can_patch?(significant) && @parser_options.except(:ruby_version).empty? ? :static : :dynamic
 
         classification(kind, operations: operations, node_path: covering_path(significant))
       end

data/lib/herb/dev/runner.rb

@@ -146,7 +146,12 @@ module Herb
 
       #: () -> bool
       def interactive?
-        $stdout.tty?
+        $stdout.tty? && !process_manager?
+      end
+
+      #: () -> bool
+      def process_manager?
+        ENV.key?("PS")
       end
 
       #: (String) -> void

data/lib/herb/engine/compiler.rb

@@ -238,6 +238,10 @@ module Herb
         process_erb_tag(node)
       end
 
+      def visit_erb_strict_locals_node(node)
+        process_erb_tag(node)
+      end
+
       def visit_erb_control_node(node, &)
         if node.content
           if node.tag_opening && erb_escaped?(node.tag_opening.value)
@@ -282,7 +286,7 @@ module Herb
       end
 
       def visit_erb_case_node(node)
-        visit_erb_control_with_parts(node, *case_parts(node))
+        visit_erb_case_parts(node)
       end
 
       def visit_erb_when_node(node)
@@ -318,7 +322,7 @@ module Herb
       end
 
       def visit_erb_case_match_node(node)
-        visit_erb_control_with_parts(node, *case_parts(node))
+        visit_erb_case_parts(node)
       end
 
       def visit_erb_in_node(node)
@@ -389,14 +393,18 @@ module Herb
         end
       end
 
-      def case_parts(node)
+      def visit_erb_case_parts(node)
         parts = [:conditions, :else_clause, :end_node]
 
-        erb_escaped?(node.tag_opening.value) ? [:children, *parts] : parts
+        return visit_erb_control_with_parts(node, :children, *parts) if erb_escaped?(node.tag_opening.value)
+
+        visit_erb_control_with_parts(node, *parts) { skip_case_children(node.children) }
       end
 
-      def visit_erb_control_with_parts(node, *parts)
+      def visit_erb_control_with_parts(node, *parts, &)
         visit_erb_control_node(node) do
+          yield if block_given?
+
           parts.each do |part|
             value = node.send(part)
             case value
@@ -813,15 +821,17 @@ module Herb
 
         return true if trailing_indentation?(text)
 
-        whitespace_only?(text) && (preceding_text_ends_with_newline? || @last_trim_consumed_newline)
+        whitespace_only?(text) && (preceding_token_value_ends_with_newline? || @last_trim_consumed_newline)
       end
 
-      def preceding_text_ends_with_newline?
+      def preceding_token_value_ends_with_newline?
         return true unless @tokens.length >= 2
 
         preceding = @tokens[-2]
 
-        preceding[0] == :text && preceding[1].end_with?("\n")
+        return @last_trim_consumed_newline if EXPRESSION_TOKEN_TYPES.include?(preceding[0])
+
+        preceding[1].end_with?("\n")
       end
 
       def extract_and_remove_leading_space!
@@ -846,8 +856,11 @@ module Herb
 
         follows_newline = leading_space_follows_newline?
         removed_whitespace = left_trim?(node) ? remove_trailing_whitespace_from_last_token! : ""
+        line_start = at_line_start?
 
-        if at_line_start?
+        drop_pending_trim_newline! if follows_trimmed_statement_tag?(node)
+
+        if line_start
           leading_space = extract_and_remove_leading_space!
           effective_leading_space = leading_space.empty? ? removed_whitespace : leading_space
           right_space = if Herb::Engine::Helpers.heredoc?(code)
@@ -858,15 +871,12 @@ module Herb
                           " \n"
                         end
 
-          @pending_leading_whitespace_insert_index = @tokens.length
-          @pending_leading_whitespace = effective_leading_space if !effective_leading_space.empty? && follows_newline
+          save_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
 
-          if right_space.end_with?(" \n")
-            @pending_trim_newline_index = @tokens.length - 1
-            @pending_trim_owns_next_whitespace = true
-          end
+          @pending_trim_newline_index = @tokens.length - 1 if right_space.end_with?(" \n")
+          @pending_trim_owns_next_whitespace = true if right_space.end_with?(" \n") || without_source?(node)
         else
           @tokens << [:code, code, current_context]
         end
@@ -899,20 +909,43 @@ module Herb
       #: (bool) -> void
       def settle_pending_trim_newline!(keep)
         index = @pending_trim_newline_index
-
-        return unless index
-
         owned = @pending_trim_owns_next_whitespace
 
+        return unless index || owned
+
         @pending_trim_newline_index = nil
         @pending_trim_owns_next_whitespace = false
 
         return if keep
 
-        @tokens[index][1] = @tokens[index][1].chomp
+        @tokens[index][1] = @tokens[index][1].chomp if index
         @trim_next_whitespace = false if owned
       end
 
+      #: (Array[untyped]) -> void
+      def skip_case_children(children)
+        text = children.grep(Herb::AST::HTMLTextNode).map(&:content).join
+
+        settle_pending_trim_newline!(true) if text.match?(/\A[ \t]*\r?\n/)
+      end
+
+      #: (untyped) -> bool
+      def follows_trimmed_statement_tag?(node)
+        return false if without_source?(node)
+
+        !@pending_trim_newline_index.nil? && @pending_trim_newline_index == @tokens.length - 1
+      end
+
+      #: () -> void
+      def drop_pending_trim_newline!
+        index = @pending_trim_newline_index
+        return unless index
+
+        @tokens[index][1] = @tokens[index][1].chomp
+        @pending_trim_newline_index = nil
+        @pending_trim_owns_next_whitespace = false
+      end
+
       def save_pending_leading_whitespace!(whitespace)
         @pending_leading_whitespace = whitespace
         @pending_leading_whitespace_insert_index = @tokens.length

data/lib/herb/engine/slots/dynamics_compiler.rb

@@ -71,7 +71,8 @@ module Herb
       # An item is keyed by the key its template declares, through `herb-key` or `id` or a
       # `<%# herb:key %>` directive, which is what makes it survive being reordered. `Visitor`
       # decides what that key is and this evaluates it, so an item arrives under the same key the
-      # marker around it carries. A collection that declares none falls back to position.
+      # marker around it carries. A collection that declares none falls back to position, counting
+      # from the first iteration, so a change re-renders every row from the first one that differs.
       #
       # ## A partial keeps its own values
       #
@@ -94,7 +95,7 @@ module Herb
       #
       # ## Blocks
       #
-      # A tag that takes a block, such as `<%= form_with do |f| %>`, owns an entry holding everything
+      # A tag that takes a block, such as `<%= form_with do |f| %>`, owns an entry holding the markup
       # the block rendered, because the helper wraps that output in markup of its own that only the
       # helper can produce. What the template wrote inside the block keeps its own indices alongside:
       #
@@ -105,6 +106,20 @@ module Herb
       # and the whole block. Slot 1 is inside slot 0, which the client already has to reason about
       # for conditionals and collections.
       #
+      # A partial inside a block is the exception to that fallback. It keeps its own values on its slot,
+      # and the block's entry is a String that cannot hold them, so the entry leaves the partial's
+      # markup out:
+      #
+      #     <%= form_with(model: @user) do |f| %><%= render "card" %><% end %>
+      #     #=> { 0 => "<form></form>", 1 => { template: "app/views/_card.html.erb", ... } }
+      #
+      # That entry cannot stand in for the block, so it must not be written over a block holding a
+      # partial. The client never writes a block's entry while the page marks slots inside that block.
+      # It reports the block as deferred instead, even when nothing in the block changed.
+      #
+      # A render that comes back as markup, because its template is not compiled for slots, is written
+      # into the entry as usual, and the entry stays whole.
+      #
       # A block yielding more than once is the exception, since one index cannot stand for the several
       # values its interior took. `each` and the other iterations are compiled as collections for that
       # reason, and a helper that yields repeatedly reports the last value its interior took.
@@ -117,6 +132,7 @@ module Herb
         ITEMS_BUFFER = "__herb_items" #: String
         KEY_BUFFER = "__herb_key" #: String
         OCCURRENCE_BUFFER = "__herb_occurrence" #: String
+        RENDERED_BUFFER = "__herb_rendered" #: String
 
         BRANCHING_NODES = [
           "AST_ERB_IF_NODE",
@@ -189,6 +205,16 @@ module Herb
             @current_node = previous
           end
 
+          #: (untyped) -> void
+          def visit_ruby_literal_node(node)
+            previous = @current_node
+            @current_node = node
+
+            super
+          ensure
+            @current_node = previous
+          end
+
           #: (untyped) -> void
           def visit_erb_yield_node(node)
             previous = @current_node
@@ -287,14 +313,15 @@ module Herb
 
             return super if erb_escaped?(opening)
 
-            should_escape = should_escape_output?(opening)
+            rendering = node.is_a?(Herb::AST::ERBRenderNode)
+            should_escape = !rendering && should_escape_output?(opening)
             index = claim(node)
 
             @tokens << [
               should_escape ? :expr_block_escaped : :expr_block,
               node.content.value.strip,
               current_context,
-              index
+              [index, rendering]
             ]
 
             @last_trim_consumed_newline = false
@@ -325,7 +352,9 @@ module Herb
 
                 @engine.send(:add_dynamic, value, context, index, escaped, nested: nested)
               when :expr_block, :expr_block_escaped
-                @engine.send(:add_dynamic_block, value, extra, type == :expr_block_escaped)
+                index, rendering = extra
+
+                @engine.send(:add_dynamic_block, value, index, type == :expr_block_escaped, rendering: rendering)
               when :expr_block_end
                 @engine.send(:add_expression_block_end, value, escaped: extra)
               end
@@ -451,7 +480,7 @@ module Herb
 
           #: (Integer) -> String?
           def item_key(index)
-            @slot_visitor.slots[index]&.key_expression
+            @slot_visitor.slots[index]&.item_key
           end
 
           #: (untyped, Symbol) -> void
@@ -531,6 +560,7 @@ module Herb
         #: (String, ?Hash[Symbol, untyped]) -> void
         def initialize(input, properties = {})
           @block_depth = 0
+          @nested_renders = [] #: Array[[Integer?]?]
           @scopes = [] #: Array[Integer]
           @withheld = {} #: Hash[Integer, bool]
           @input = input
@@ -589,6 +619,8 @@ module Herb
               return add_block_dynamic("(#{assignment(index, value)}).fetch(-1)")
             end
 
+            return add_block_render(index ? assignment(index, value) : value) if nested
+
             return add_block_dynamic(index ? assignment(index, value) : value)
           end
           return if index.nil?
@@ -601,19 +633,24 @@ module Herb
           @slot_visitor.slots[index]&.type == :boolean_attribute
         end
 
-        #: (String, Integer?, bool) -> void
-        def add_dynamic_block(code, index, escaped)
+        #: (String, Integer?, bool, ?rendering: bool) -> void
+        def add_dynamic_block(code, index, escaped, rendering: false)
           @_in_expression_block = true
           @_expression_block_open_paren = true
 
           opening = escaped ? "#{@escapefunc}((" : "("
+          nested_render = rendering && !@block_depth.zero?
 
           @src << if @block_depth.zero?
                     "; #{current_scope}[#{index}] = #{opening}#{code}"
+                  elsif nested_render
+                    "; #{RENDERED_BUFFER} = #{opening}#{code}"
                   else
                     "; #{@bufvar} << #{opening}#{code}"
                   end
 
+          @nested_renders.push(nested_render ? [index] : nil)
+
           open_block
         end
 
@@ -624,6 +661,14 @@ module Herb
           close_block
 
           super
+
+          nested_render = @nested_renders.pop
+
+          return unless nested_render
+
+          index = nested_render.first
+
+          add_block_render(index ? assignment(index, RENDERED_BUFFER) : RENDERED_BUFFER)
         end
 
         #: () -> String
@@ -728,6 +773,10 @@ module Herb
         #: (Integer) -> void
         def scope_open_collection(index)
           @src << "; #{ITEMS_BUFFER}#{index} = ::Hash.new;"
+
+          slot = @slot_visitor.slots[index]
+
+          @src << "; #{slot.position_variable} = -1;" if slot&.positional?
         end
 
         #: (Integer, ?String?) -> void
@@ -742,17 +791,12 @@ module Herb
         def scope_item_end(index)
           leave_scope(index)
 
-          return unless keyed?(index)
+          return unless @slot_visitor.slots[index]&.item_key
 
           @src << item_seeds(index)
           @src << "; #{ITEMS_BUFFER}#{index}[#{KEY_BUFFER}#{index}.to_s] = #{SCOPE_BUFFER}#{index};"
         end
 
-        #: (Integer) -> bool
-        def keyed?(index)
-          !@slot_visitor.slots[index]&.key_expression.nil?
-        end
-
         #: (Integer) -> String
         def item_seeds(index)
           names = @slot_visitor.seeded_item_states[index]
@@ -816,6 +860,11 @@ module Herb
           @slot_visitor.slots[index]&.interpolated? || false
         end
 
+        #: (String) -> void
+        def add_block_render(value)
+          add_block_dynamic("::Hash === (#{RENDERED_BUFFER} = (#{value})) ? \"\" : #{RENDERED_BUFFER}.to_s")
+        end
+
         #: (String) -> void
         def add_block_dynamic(value)
           @src << "; " << @bufvar << " << (" << value << ");"

data/lib/herb/engine/slots/markers.rb

@@ -10,6 +10,10 @@ module Herb
         SEED_VALUE_TYPES = "[true, false, ::Integer, ::String, ::Symbol, nil]" #: String
         PREFIX = "herb-" #: String
         COMMENT = %r{\A<!--/?#{PREFIX}} #: Regexp
+        FOREIGN_ATTRIBUTE = "data-herb-foreign" #: String
+        FOREIGN_ROOTS = { svg: "svg", math: "math" }.freeze #: Hash[Symbol, String]
+        SVG_INTEGRATION_POINTS = ["foreignobject", "desc", "title"].freeze #: Array[String]
+        MATH_INTEGRATION_POINTS = ["mi", "mo", "mn", "ms", "mtext"].freeze #: Array[String]
 
         #: (String) -> bool
         def self.marker?(text)
@@ -21,6 +25,18 @@ module Herb
           "{ #{pairs} }.select { |_, v| #{SEED_VALUE_TYPES}.any? { |t| t === v } }.transform_values { |v| v.is_a?(::Symbol) ? v.to_s : v }"
         end
 
+        #: (Symbol, String) -> Symbol
+        def self.namespace_within(namespace, tag_name)
+          case namespace
+          when :svg
+            SVG_INTEGRATION_POINTS.include?(tag_name) ? :html : :svg
+          when :math
+            MATH_INTEGRATION_POINTS.include?(tag_name) ? :html : :math
+          else
+            FOREIGN_ROOTS.key(tag_name) || :html
+          end
+        end
+
         #: (Integer, Symbol) -> String
         def slot_open(index, type)
           return "<!--#{PREFIX}slot:#{index}-->" if type == DEFAULT_TYPE
@@ -28,6 +44,14 @@ module Herb
           "<!--#{PREFIX}slot:#{index}:#{type}-->"
         end
 
+        #: (String, Symbol) -> String
+        def foreign(markup, namespace)
+          root = FOREIGN_ROOTS[namespace]
+          return markup unless root
+
+          %(<#{root} #{FOREIGN_ATTRIBUTE}>#{markup}</#{root}>)
+        end
+
         #: (Array[[Integer, Symbol, String?]]) -> String
         def element_anchors(anchors)
           anchors.map { |index, type, name| name ? "#{index}:#{type}:#{name}" : "#{index}:#{type}" }.join(" ")

data/lib/herb/engine/slots/state_compiler.rb

@@ -1311,8 +1311,7 @@ module Herb
           return nil unless position
 
           condition = StateDirectives.condition_source(read)
-          spacing = open_tag.is_a?(Herb::AST::ERBOpenTagNode) ? " " : ""
-          replacement = @visitor.erb_output_node(%[("#{spacing}#{slot.attribute}" if #{condition})])
+          replacement = @visitor.erb_output_node(%[("#{@visitor.attribute_spacing(children, position)}#{slot.attribute}" if #{condition})])
 
           children[position] = replacement
 

data/lib/herb/engine/slots/subtree_compiler.rb

@@ -186,7 +186,7 @@ module Herb
 
           #: (*untyped) { () -> void } -> void
           def indexing(*arrays)
-            marked = arrays.select { |array| array.is_a?(Array) }
+            marked = arrays.grep(Array)
             marked.each { |array| @indexed[array] = true }
 
             yield