herb 0.11.0-arm-linux-gnu → 0.11.1-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c51f69728155d005466de2eee9a4be0eabb5ac84d476884a532f4c0b59517c
-  data.tar.gz: c666b72f5a6cf58572626446e54fc8cdd0c49c532785cbb1a18482072660f627
+  metadata.gz: c909ec1f68c66ff62e3cd2a17402ed4d59154334c7edbbc252a8708e276efe47
+  data.tar.gz: 6acd5e979521f52034f4011c58d4275a9dbb4571912eed54bd8862c89e65495b
 SHA512:
-  metadata.gz: 7b2810ffb15ca2e27b564fecdacd60313df5621092be2452a98949ee655d1a37bb4051cd06cc425d8b5fdb1eef2d07e482abeba25b06ea83b19042f2bef3d28d
-  data.tar.gz: b2572479f17787cad72270b4dee70baaf7de8a5bf81b02320e2c8ce9bb73ed954c932aa6f867f93b7bc61c22aa76d3dd9ff6cb528a7a7595bd6feedbacf09a76
+  metadata.gz: eb7679d9a101d75068ec7d3a35bbe275907aecffb40d75bc45f6a98a54f9ca012cf43d98e95c461b454dd19639f5d5a2fa3e4a93a9cb481eede5c3a531a9ea79
+  data.tar.gz: 29beb686a1d5289be4bb1a7e38f0409a50da0d4664ed4a09aeff46da837d281a26261111fd21471d3543280fb01282edec22aa30dd3e22919c90d76b5c3478b4

data/config.yml

@@ -1739,6 +1739,9 @@ nodes:
         - name: "tag_closing"
           type: "token"
 
+        - name: "prism_node"
+          type: "prism_node"
+
     - name: "ERBInNode"
       fields:
         - name: "tag_opening"

data/ext/herb/nodes.c

@@ -141,7 +141,7 @@ static VALUE rb_document_node_from_c_struct(AST_DOCUMENT_NODE_T* document_node,
   VALUE document_node_prism_node;
   if (document_node->prism_node.node != NULL && document_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(document_node->prism_node.parser, document_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(document_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       document_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -821,7 +821,7 @@ static VALUE rb_erb_content_node_from_c_struct(AST_ERB_CONTENT_NODE_T* erb_conte
   VALUE erb_content_node_prism_node;
   if (erb_content_node->prism_node.node != NULL && erb_content_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_content_node->prism_node.parser, erb_content_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_content_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_content_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -934,7 +934,7 @@ static VALUE rb_erb_if_node_from_c_struct(AST_ERB_IF_NODE_T* erb_if_node, const
   VALUE erb_if_node_prism_node;
   if (erb_if_node->prism_node.node != NULL && erb_if_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_if_node->prism_node.parser, erb_if_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_if_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_if_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -988,7 +988,7 @@ static VALUE rb_erb_block_node_from_c_struct(AST_ERB_BLOCK_NODE_T* erb_block_nod
   VALUE erb_block_node_prism_node;
   if (erb_block_node->prism_node.node != NULL && erb_block_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_block_node->prism_node.parser, erb_block_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_block_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_block_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1047,7 +1047,7 @@ static VALUE rb_erb_iteration_block_node_from_c_struct(AST_ERB_ITERATION_BLOCK_N
   VALUE erb_iteration_block_node_prism_node;
   if (erb_iteration_block_node->prism_node.node != NULL && erb_iteration_block_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_iteration_block_node->prism_node.parser, erb_iteration_block_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_iteration_block_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_iteration_block_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1151,7 +1151,7 @@ static VALUE rb_erb_case_node_from_c_struct(AST_ERB_CASE_NODE_T* erb_case_node,
   VALUE erb_case_node_prism_node;
   if (erb_case_node->prism_node.node != NULL && erb_case_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_case_node->prism_node.parser, erb_case_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_case_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_case_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1206,7 +1206,7 @@ static VALUE rb_erb_case_match_node_from_c_struct(AST_ERB_CASE_MATCH_NODE_T* erb
   VALUE erb_case_match_node_prism_node;
   if (erb_case_match_node->prism_node.node != NULL && erb_case_match_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_case_match_node->prism_node.parser, erb_case_match_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_case_match_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_case_match_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1260,7 +1260,7 @@ static VALUE rb_erb_while_node_from_c_struct(AST_ERB_WHILE_NODE_T* erb_while_nod
   VALUE erb_while_node_prism_node;
   if (erb_while_node->prism_node.node != NULL && erb_while_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_while_node->prism_node.parser, erb_while_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_while_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_while_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1311,7 +1311,7 @@ static VALUE rb_erb_until_node_from_c_struct(AST_ERB_UNTIL_NODE_T* erb_until_nod
   VALUE erb_until_node_prism_node;
   if (erb_until_node->prism_node.node != NULL && erb_until_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_until_node->prism_node.parser, erb_until_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_until_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_until_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1362,7 +1362,7 @@ static VALUE rb_erb_for_node_from_c_struct(AST_ERB_FOR_NODE_T* erb_for_node, con
   VALUE erb_for_node_prism_node;
   if (erb_for_node->prism_node.node != NULL && erb_for_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_for_node->prism_node.parser, erb_for_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_for_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_for_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1479,7 +1479,7 @@ static VALUE rb_erb_begin_node_from_c_struct(AST_ERB_BEGIN_NODE_T* erb_begin_nod
   VALUE erb_begin_node_prism_node;
   if (erb_begin_node->prism_node.node != NULL && erb_begin_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_begin_node->prism_node.parser, erb_begin_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_begin_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_begin_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1537,7 +1537,7 @@ static VALUE rb_erb_unless_node_from_c_struct(AST_ERB_UNLESS_NODE_T* erb_unless_
   VALUE erb_unless_node_prism_node;
   if (erb_unless_node->prism_node.node != NULL && erb_unless_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_unless_node->prism_node.parser, erb_unless_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_unless_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_unless_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1685,7 +1685,7 @@ static VALUE rb_erb_render_node_from_c_struct(AST_ERB_RENDER_NODE_T* erb_render_
   VALUE erb_render_node_prism_node;
   if (erb_render_node->prism_node.node != NULL && erb_render_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_render_node->prism_node.parser, erb_render_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_render_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_render_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1781,7 +1781,7 @@ static VALUE rb_erb_strict_locals_node_from_c_struct(AST_ERB_STRICT_LOCALS_NODE_
   VALUE erb_strict_locals_node_prism_node;
   if (erb_strict_locals_node->prism_node.node != NULL && erb_strict_locals_node->prism_node.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(erb_strict_locals_node->prism_node.parser, erb_strict_locals_node->prism_node.node, &pm_buffer);
+    herb_prism_node_serialize(erb_strict_locals_node->prism_node, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       erb_strict_locals_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
@@ -1828,17 +1828,34 @@ static VALUE rb_erb_yield_node_from_c_struct(AST_ERB_YIELD_NODE_T* erb_yield_nod
   VALUE erb_yield_node_tag_opening = rb_token_from_c_struct(erb_yield_node->tag_opening, options);
   VALUE erb_yield_node_content = rb_token_from_c_struct(erb_yield_node->content, options);
   VALUE erb_yield_node_tag_closing = rb_token_from_c_struct(erb_yield_node->tag_closing, options);
+  VALUE erb_yield_node_prism_node;
+  if (erb_yield_node->prism_node.node != NULL && erb_yield_node->prism_node.parser != NULL) {
+    pm_buffer_t pm_buffer = { 0 };
+    herb_prism_node_serialize(erb_yield_node->prism_node, &pm_buffer);
 
-  VALUE args[6] = {
+    if (pm_buffer.length > 0) {
+      erb_yield_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
+      rb_enc_associate(erb_yield_node_prism_node, rb_ascii8bit_encoding());
+      OBJ_FREEZE(erb_yield_node_prism_node);
+    } else {
+      erb_yield_node_prism_node = Qnil;
+    }
+    pm_buffer_free(&pm_buffer);
+  } else {
+    erb_yield_node_prism_node = Qnil;
+  }
+
+  VALUE args[7] = {
     type,
     location,
     errors,
     erb_yield_node_tag_opening,
     erb_yield_node_content,
-    erb_yield_node_tag_closing
+    erb_yield_node_tag_closing,
+    erb_yield_node_prism_node
   };
 
-  return rb_class_new_instance(6, args, cERBYieldNode);
+  return rb_class_new_instance(7, args, cERBYieldNode);
 };
 
 static VALUE rb_erb_in_node_from_c_struct(AST_ERB_IN_NODE_T* erb_in_node, const parser_options_T* options) {

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/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?
+
+        drop_pending_trim_newline! if follows_trimmed_statement_tag?(node)
 
-        if at_line_start?
+        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,8 +871,7 @@ 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
 
@@ -913,6 +925,30 @@ module Herb
         @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

@@ -189,6 +189,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

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