rblade 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5760d0a2af4a86bf0ffcc9451abb3a46357029b9f5fea33afdf8305282c3d5e3
-  data.tar.gz: aaf764e044528fac1287219268ed117d332fd13204eb52971de9a88402665780
+  metadata.gz: 565a823219a85db94f6fa31e42de52cab5d1de562c89c42243a0105d54eab581
+  data.tar.gz: 484ca84492233eabd1c61a534be991cfdb489273751e4e43a1b5ac400965b867
 SHA512:
-  metadata.gz: d38f0abf519963a665c5780a2e2328f4bc357455c2cbec99d49362eb76f4529ece7edd65b08ec4c9669700a2c0fca5feeade897fff938aa5c8ed64790f96c152
-  data.tar.gz: 4ef6e7d9bffb6b9a4360af6ffe7030d9cac15ce6b3c67da546af9739659cb68ea801f06e4ddeaa67f66ce48e4885d4b2931a090518d39b05b994592bd7db0447
+  metadata.gz: a3fa94d7c7c3f19f3671dd346bffedbee1fdaaf3b93ce0928cba1b6bb7d24a7c7da83c016863df9aa8c5cbdd0d5519d65efef7aa18a59a77a7861764e8188f03
+  data.tar.gz: 29325e82f35eb1e6b949b49684ea5c78cea910ffeeacf18ef012c39ff6cbe2a73e26bd47d1753734cc712421b19a958dab54224c024c25ca580b53b34b6dcb9a

data/.github/workflows/ruby.yml

@@ -31,5 +31,9 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+    - name: Run rubocop rules
+      run: bundle exec rubocop
+
     - name: Run tests
       run: bundle exec rake

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 3.1.0 [2025-04-02]
+- Add ability to use slots in dynamic components and the component view helper method
+- Change statement matching to use regular expressions to improve compile performance
+
+## 3.0.1 [2025-03-18]
+- Fix dynamic components not working when `RBlade.component_helper_method_name` is set
+
 ## 3.0.0 [2025-03-18]
 - Add ability to add raw directive handlers that add ruby code to the template
 - Add `RBlade.direct_component_rendering` option to allow RBlade components to be rendered directly

data/README.md

@@ -62,6 +62,7 @@ For a quick overview of RBlade's capabilities, refer to the [reference file](REF
     + [Method Field](#method-field)
   * [Stacks](#stacks)
   * [Integrating RBlade With Other Templates](#rblade-integration)
+  * [Limitations](#limitations)
 
 <a name="displaying-data"></a>
 ## Displaying Data
@@ -976,7 +977,40 @@ If you would like to prepend content onto the beginning of a stack, you should u
 <a name="rblade-integration"></a>
 ## Integrating RBlade With Other Templates
 
-You might want to use RBlade components within other templates, e.g. if you are using a component library that uses them. By default, RBlade components cannot be rendered directly, but this can be enabled using the `direct_component_rendering` option. 
+You might want to use RBlade components within other templates, e.g. if you are using a component library that uses them. The `component` helper method lets you easily include RBlade components in your ERB (or other) templates:
+
+```erb
+<%= component "button", class: "mt-4", colour: "green" do %>
+  <b>My button</b>
+<% end %>
+```
+
+The component method also passes a proc that can be used to specify slots:
+
+```erb
+<%= component "card" do |slot| %>
+  <%# The "class" attribute and the contents of the block will be passed in as the "heading" attribute to the card component %>
+  <% slot :heading, class: "font-bold" do %>
+    Heading
+  <% end %>
+  Content
+<% end %>
+```
+
+If preferred, the `component` method can be renamed using the `RBlade.component_helper_method_name` option:
+
+```ruby
+# config/initializers/rblade.rb
+
+# Change the name of the component helper method
+RBlade.component_helper_method_name = :rblade_component
+
+
+# app/views/home/show.erb
+<%= rblade_component "my_component" %>
+```
+
+By default, RBlade layouts are not compatible with other templates, and components cannot be rendered directly, but this can be enabled using the `direct_component_rendering` option. 
 
 ```ruby
 # config/initializers/rblade.rb
@@ -985,13 +1019,53 @@ You might want to use RBlade components within other templates, e.g. if you are
 RBlade.direct_component_rendering = true
 ```
 
-Once enabled, RBlade components can be rendered using `render partial: ...`. Block contents are passed to the component in the `slot` variable, `attributes` is initialized using `local_assigns`, and the `@props` directive will look for content set using `content_for`.
+Once enabled, RBlade components can be used as layouts for ERB templates, or rendered directly using `render`. Block contents are passed to the component in the `slot` variable, `attributes` is initialized using `local_assigns`, and the `@props` directive will look for content set using `content_for`.
 
 ```erb
 <%= render template: "components/button", locals: {class: "mt-4", slot: capture do %>
-  
+  <% content_for: :title, "My title" %>
+  <b>My content</b>
 <% end } %>
 ```
 
 > [!NOTE]  
-> RBlade's `{{ }}` print directives are automatically sent through Rails' `h` function to prevent XSS attacks.
+> Using the `component` helper instead of RBlade's component syntax does not take advantage of RBlade's component caching
+
+
+<a name="limitations"></a>
+## Limitations
+
+### Regular expressions in RBlade directives
+
+Regular expression literals may cause improper bracket matching in RBlade directive. To work around this, use the `%r` percent literal syntax.
+
+```rblade
+{{-- Parentheses in regular expressions may cause incorrect matching --}}
+@ruby(/\)/)
+
+{{-- A workaround is to use the alternative %r syntax --}}
+@ruby(%r/\)/)
+```
+
+### `<<` in RBlade directives
+
+The append operator is assumed to be a HEREDOC if followed immediately by a word character (a-z, A-Z, _), `-` or `~`.
+
+```rblade
+{{-- If using `<<` to append, add a space after the operator --}}
+@ruby(string << "extra")
+```
+
+### End brackets in print statements
+
+Print statements cannot contain their end bracket in strings or other literals:
+
+```rblade
+# These examples will cause a syntax error
+{{ '}}' }}
+<%= 'foo%>' %>
+
+# A workaround is to use the alternative syntax
+<%= 'foo}}' %>
+{{ 'foo%>' }}
+```

data/Rakefile

@@ -3,4 +3,4 @@ require "standard/rake"
 
 Minitest::TestTask.create
 
-task default: ["standard", "test"]
+task default: ["test"]

data/do

@@ -43,36 +43,36 @@ fi
 
 if [ "$1" == "run" ] || [ "$1" == "r" ]
 then
-    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade ${@:2}
-    ${DOCKER_COMPOSE_COMMAND} run blade "${@:2}"
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade ${@:2}
+    ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade "${@:2}"
     exit 0
 fi
 
 if [ "$1" == "rake" ] || [ "$1" == "rk" ]
 then
-    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake ${@:2}
-    ${DOCKER_COMPOSE_COMMAND} run blade rake "${@:2}"
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rake ${@:2}
+    ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rake "${@:2}"
     exit 0
 fi
 
 if [ "$1" == "cs" ] || [ "$1" == "c" ]
 then
-    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rubocop "${@:2}"
-    ${DOCKER_COMPOSE_COMMAND} run blade rubocop "${@:2}"
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rubocop "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rubocop "${@:2}"
     exit 0
 fi
 
 if [ "$1" == "cs:fix" ]
 then
-    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rubocop --autocorrect "${@:2}"
-    ${DOCKER_COMPOSE_COMMAND} run blade rubocop --autocorrect "${@:2}"
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rubocop --autocorrect "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rubocop --autocorrect "${@:2}"
     exit 0
 fi
 
 if [ "$1" == "test" ] || [ "$1" == "t" ]
 then
-    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake test "${@:2}"
-    ${DOCKER_COMPOSE_COMMAND} run blade rake test "${@:2}"
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rake test "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run --remove-orphans --rm blade rake test "${@:2}"
     exit 0
 fi
 

data/lib/rblade/compiler/compiles_comments.rb

@@ -7,7 +7,7 @@ module RBlade
         next if token.type != :unprocessed
 
         token.value.gsub!(/\{\{--(?:[^-]++|-)*?--}}/, "")
-        token.value.gsub!(/<%#(?:[^%]++|-)*?%>/, "")
+        token.value.gsub!(/<%#(?:[^%]++|%)*?%>/, "")
       end
     end
   end

data/lib/rblade/compiler/compiles_components.rb

@@ -45,7 +45,7 @@ module RBlade
       attributes = compile_attributes token.value[:attributes]
 
       if component[:name].start_with? "slot::"
-        "_slot.call(:'#{RBlade.escape_quotes(component[:name].delete_prefix("slot::"))}', {#{attributes.join(",")}}) do;"
+        "_slot.call(:'#{RBlade.escape_quotes(component[:name].delete_prefix("slot::"))}', **{#{attributes.join(",")}}) do;"
       else
         "#{@component_store.component(component[:name])}(RBlade::AttributesManager.new({#{attributes.join(",")}})) do |_slot|;"
       end
@@ -67,7 +67,7 @@ module RBlade
 
       attributes = compile_attributes token.value[:attributes]
 
-      "@output_buffer.raw_buffer<<component(#{component_value}, '#{RBlade.escape_quotes(@component_store.current_view_name)}', #{attributes.join ","}) do;"
+      "@output_buffer.raw_buffer<<#{RBlade.component_helper_method_name}(#{component_value}, '#{RBlade.escape_quotes(@component_store.current_view_name)}', #{attributes.join ","}) do |_slot|;"
     end
 
     def compile_token_end(token)

data/lib/rblade/compiler/statements/compiles_component_helpers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "rblade/helpers/tokenizer"
-
 module RBlade
   class CompilesStatements
     class CompilesComponentHelpers

data/lib/rblade/compiler/tokenizes_statements.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "rblade/helpers/tokenizer"
+require "rblade/helpers/regular_expressions"
 require "ripper"
 
 module RBlade
@@ -9,161 +9,171 @@ module RBlade
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
-        segments = token.value.split(/
-          (\s)?(?<!\w)
+        current_match_id = nil
+        segments = []
+        token.value.split(/
+          \s?(?<!\w|@)
           (?:
             (?:
-              (@@)
-              (\w++[!\?]?)
+              (?<escaped_at>@@)
+              (?=\w++[!\?]?(?!\w))
             )
             |
             (?:
-              (@)
-              (\w++[!\?]?)
-              (?:([ \t]*+)
-                (\([^)]*+\))
+              @
+              (?# Statement name )
+              (?<statement_name>\w++[!\?]?)
+              (?# Optional parameters )
+              (?:
+                [ \t]*+
+                (?# Matched parentheses )
+                (?<statement_arguments>
+                  \(
+                    (?:
+                      [^()#{RegularExpressions::RUBY_STRING_CHARACTERS}]++
+                      |
+                      #{RegularExpressions::RUBY_STRING}
+                      |
+                      \g<statement_arguments>
+                    )*+
+                  \)
+                )
               )?
             )
           )
-          (\s)?
-        /x)
-
-        parse_segments! segments
-      end.flatten!
-    end
-
-    private
-
-    def parse_segments!(segments)
-      i = 0
-      while i < segments.count
-        segment = segments[i]
-
-        # The @ symbol is used to escape blade directives so we return it unprocessed
-        if segment == "@@"
-          segments[i] = Token.new(type: :unprocessed, value: segment[1..] + segments[i + 1])
-          segments.delete_at i + 1
-
-          i += 1
-        elsif segment == "@"
-          statement_handle = segments[i + 1].downcase.tr "_", ""
-          if CompilesStatements.has_handler(statement_handle)
-            tokenize_statement! statement_handle, segments, i
-            handle_special_cases! segments, i
-
-            segments.delete_at(i + 1) if segments[i + 1]&.match?(/\A\s\z/)
-            if segments[i - 1].is_a?(Token) && segments[i - 1].type == :unprocessed && segments[i - 1].value.match?(/\A\s\z/)
-              segments.delete_at i - 1
-              i -= 1
+          \s?
+        /xo) do |before_match|
+          next if current_match_id == $~.object_id
+          current_match_id = $~.object_id
+
+          # Add the current string to the segment list
+          unless before_match == ""
+            # Skip output between case and when statements
+            unless segments.last&.type == :statement && segments.last&.value&.[](:name) == "case"
+              if segments.last && segments.last.type == :unprocessed
+                segments.last.value << before_match
+              else
+                segments << Token.new(type: :unprocessed, value: before_match)
+              end
             end
-          else
-            # For unhandled statements, restore the original string
-            segments[i] = Token.new(type: :unprocessed, value: segments[i] + segments[i + 1])
-            segments.delete_at i + 1
-
-            if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*+\z/) && segments[i + 2][0] == "("
-              segments[i].value += segments[i + 1] + segments[i + 2]
-              segments.delete_at i + 1
-              segments.delete_at i + 1
-            elsif segments.count > i + 1 && segments[i + 1][0] == "("
-              segments[i].value += segments[i + 1]
-              segments.delete_at i + 1
+          end
+          next if $~.nil?
+
+          # Skip escaped statements
+          if $~&.[](:escaped_at) == "@@"
+            segment = $&
+            # Remove the first or second @, depending on whether there is whitespace
+            segment.slice!(1).inspect
+            if segments.last && segments.last.type == :unprocessed
+              segments.last.value << segment
+            else
+              segments << Token.new(type: :unprocessed, value: segment)
             end
+
+            next
           end
 
-          i += 1
-        elsif !segments[i].nil? && segments[i] != ""
-          segments[i] = Token.new(type: :unprocessed, value: segments[i])
+          statement_handle = $~[:statement_name].downcase.tr("_", "")
+          unless CompilesStatements.has_handler(statement_handle)
+            if segments.last && segments.last.type == :unprocessed
+              segments.last.value << $&
+            else
+              segments << Token.new(type: :unprocessed, value: $&)
+            end
 
-          i += 1
-        else
-          segments.delete_at i
-        end
-      end
+            next
+          end
 
-      segments
-    end
+          statement_data = {name: statement_handle}
 
-    def tokenize_statement!(handle, segments, i)
-      segments.delete_at i + 1
-      statement_data = {name: handle}
+          unless $~[:statement_arguments].blank?
+            arguments = tokenize_arguments! statement_handle, $~[:statement_arguments]
 
-      # Remove optional whitespace
-      if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*+\z/) && segments[i + 2][0] == "("
-        segments.delete_at i + 1
-      end
+            unless arguments.nil?
+              statement_data[:arguments] = arguments
+            end
 
-      if segments.count > i + 1 && segments[i + 1][0] == "("
-        arguments = tokenize_arguments! handle, segments, i + 1
+          end
 
-        unless arguments.nil?
-          statement_data[:arguments] = arguments
+          segments << Token.new(type: :statement, value: statement_data)
         end
-      end
 
-      segments[i] = Token.new(type: :statement, value: statement_data)
-    end
-
-    def handle_special_cases!(segments, i)
-      if segments[i][:value][:name] == "case"
-        # Remove any whitespace before a when statement
-        until segments[i + 1].nil? || segments[i + 1] == "@"
-          segments.delete_at i + 1
-        end
-      end
+        segments
+      end.flatten!
     end
 
-    def tokenize_arguments!(statement_handle, segments, segment_index)
-      success = expand_segment_to_end_parenthesis! segments, segment_index
-
-      # If no matching parentheses were found, so we combine the argument string with the next segment
-      unless success
-        unless segments[segment_index + 1].nil?
-          segments[segment_index] <<= segments[segment_index + 1]
-          segments.delete_at segment_index + 1
-        end
-
-        return nil
-      end
+    private
 
-      # Remove the parentheses from the argument string
-      argument_string = segments[segment_index][1..-2]
+    def tokenize_arguments!(statement_handle, argument_string)
+      argument_string.delete_prefix! "("
+      argument_string.delete_suffix! ")"
 
-      # Special case for the props statement: remove the wrapping braces if they exist
       if statement_handle == "props"
-        if argument_string.start_with?("{") && argument_string.end_with?("}")
-          argument_string = argument_string[1..-2]
-        end
+        # Special case for the props statement: remove wrapping braces if they exist
+        argument_string.delete_prefix! "{"
+        argument_string.delete_suffix! "}"
       end
 
-      arguments = Tokenizer.extract_comma_separated_values argument_string
-      segments.delete_at segment_index
-
-      arguments
-    end
-
-    def expand_segment_to_end_parenthesis!(segments, segment_index)
-      parentheses_difference = 0
-
-      loop do
-        tokens = Ripper.lex(segments[segment_index]).map { |token| token[1] }
-        parentheses_difference = tokens.count(:on_lparen) - tokens.count(:on_rparen)
-
-        break if parentheses_difference.zero? || segments[segment_index + 1].nil?
-
-        index = segments[segment_index + 1].each_char.find_index { |c| c == ")" && (parentheses_difference -= 1).zero? }
+      argument_string.strip!
+      return nil if argument_string == ""
 
-        if index.nil?
-          segments[segment_index] << segments[segment_index + 1]
-          segments.delete_at segment_index + 1
-        else
-          segments[segment_index] << segments[segment_index + 1].slice!(0..index)
-        end
-
-        break if segments[segment_index + 1].nil?
+      current_match_id = nil
+      arguments = []
+      argument_string.split(/
+        \G
+        (?<argument>
+          (?:
+            [^,\(\{\[#{RegularExpressions::RUBY_STRING_CHARACTERS}]++
+            |
+            #{RegularExpressions::RUBY_STRING}
+            |
+            (?<parentheses>
+              \(
+                (?:
+                  [^\(\)#{RegularExpressions::RUBY_STRING_CHARACTERS}]++
+                  |
+                  \g<string>
+                  |
+                  \g<parentheses>
+                )*+
+              \)
+            )
+            |
+            (?<brackets>
+              \[
+                (?:
+                  [^\[\]#{RegularExpressions::RUBY_STRING_CHARACTERS}]++
+                  |
+                  \g<string>
+                  |
+                  \g<brackets>
+                )*+
+              \]
+            )
+            |
+            (?<braces>
+              \{
+                (?:
+                  [^\{\}#{RegularExpressions::RUBY_STRING_CHARACTERS}]++
+                  |
+                  \g<string>
+                  |
+                  \g<braces>
+                )*+
+              \}
+            )
+          )*+
+        )
+        ,
+      /xmo, -1) do |x|
+        next if current_match_id == $~.object_id
+        current_match_id = $~.object_id
+
+        argument = ($~&.[](:argument) || x).strip
+        arguments << argument unless argument == ""
       end
 
-      parentheses_difference.zero?
+      arguments
     end
   end
 end

data/lib/rblade/component_store.rb

@@ -86,7 +86,7 @@ module RBlade
 
       compiled_component = RBlade::Compiler.compile_string(template, self)
 
-      @component_definitions << "def self._rblade_component_#{escaped_name}(attributes,&);slot=if block_given?;RBlade::SlotManager.new(@output_buffer.capture(->(name, slot_attributes, &slot_block)do;attributes[name]=RBlade::SlotManager.new(@output_buffer.capture(&slot_block), slot_attributes);end,&));end;_stacks=[];@output_buffer.raw_buffer<<@output_buffer.capture do;#{compiled_component}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));end;end;"
+      @component_definitions << "def self._rblade_component_#{escaped_name}(attributes,&);slot=if block_given?;RBlade::SlotManager.new(@output_buffer.capture(->(name, **slot_attributes, &slot_block)do;attributes[name]=RBlade::SlotManager.new(@output_buffer.capture(&slot_block), slot_attributes);end,&));end;slot.nil?;_stacks=[];@output_buffer.raw_buffer<<@output_buffer.capture do;#{compiled_component}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));end;end;"
 
       @component_method_names[name] = "_rblade_component_#{escaped_name}"
     end

data/lib/rblade/helpers/regular_expressions.rb

@@ -0,0 +1,135 @@
+module RBlade::RegularExpressions
+  RUBY_STRING_CHARACTERS = "\"'%?<"
+  RUBY_STRING = /
+    (?<string>
+    (?# Interpolated strings )
+    "
+      (?:
+        [^#"\\]++
+        |
+        \#(?<curly>\{
+          (?:
+            [^"'{}?%]++
+            |
+            \g<string>
+            |
+            \g<curly>
+          )*+
+        \})
+        |
+        \\.
+        |
+        (?!\#\{)\#[@$]?
+      )*+
+    "
+    |
+    (?# Non interpolated strings )
+    '
+      (?:
+        [^'\\]++
+        |
+        \\.
+      )*+
+    '
+    |
+    (?# Non interpolated percent expressions )
+    %[qwis]
+      (?:
+        (?<ni_parentheses> \( (?: [^()\\]++ | \\. | \g<ni_parentheses> )*+ \) )
+        |
+        (?<ni_brackets> \[ (?: [^\[\]\\]++ | \\. | \g<ni_brackets> )*+ \] )
+        |
+        (?<ni_crocs> < (?: [^<>\\]++ | \\. | \g<ni_crocs> )*+ > )
+        |
+        (?<ni_braces> \{ (?: [^{}\\]++ | \\. | \g<ni_braces> )*+ \} )
+        |
+        (?<percent_delimiter>[\x00-\x7F&&[^a-zA-Z0-9(\[{<]])
+        (?:
+          [a-zA-Z0-9(\[{<[^\x00-\x7F]]++
+          |
+          \\.
+          |
+          (?!\k<percent_delimiter>)[^\\]
+        )*?
+        \k<percent_delimiter>
+      )
+    |
+    (?# Interpolated percent expressions )
+    %[QWIrx]?
+      (?:
+        (?<i_parentheses> \( (?: [^()\\#]++ | \#\g<curly> | \\. | \g<i_parentheses> )*+ \) )
+        |
+        (?<i_brackets> \[ (?: [^\[\]\\#]++ | \#\g<curly> | \\. | \g<i_brackets> )*+ \] )
+        |
+        (?<i_crocs> < (?: [^<>\\#]++ | \#\g<curly> | \\. | \g<i_crocs> )*+ > )
+        |
+        (?<i_braces> \{ (?: [^{}\\#]++ | \#\g<curly> | \\. | \g<i_braces> )*+ \} )
+        |
+        \g<percent_delimiter>
+        (?:
+          [a-zA-Z0-9(\[{<[^\x00-\x7F]]++
+          |
+          \#\g<curly>
+          |
+          \\.
+          |
+          (?!\k<percent_delimiter>)[^\\#]
+          |
+          (?!\#\{)\#[@$]?+
+        )*?
+        (?!\#\{)\k<percent_delimiter>
+      )
+    |
+    (?# Interpolated HEREDOC)
+    <<(?:(?<heredoc_delimiter>[a-zA-Z_]\w*+)|"\g<heredoc_delimiter>")[^\n]*+\n
+    (?:
+      (?!\k<heredoc_delimiter>$)[^\#\n]++
+      |
+      \#\g<curly>
+      |
+      (?!\#\{)\#[^\#\n]++
+      |
+      \n
+    )*?
+    \n\k<heredoc_delimiter>$
+    |
+    (?# Interpolated HEREDOC with leading spaces)
+    <<[-~](?:\g<heredoc_delimiter>|"\g<heredoc_delimiter>")[^\n]*+\n
+    (?:
+      (?!\k<heredoc_delimiter>$)[^\#\n]++
+      |
+      \#\g<curly>
+      |
+      (?!\#\{)\#[^\#\n]++
+      |
+      \n
+    )*?
+    \n\s*+\k<heredoc_delimiter>$
+    |
+    (?# Non-interpolated HEREDOC)
+    <<'\g<heredoc_delimiter>'[^\n]*+\n
+    (?:
+      (?!\k<heredoc_delimiter>$)[^\n]*+\n
+    )*+
+    \k<heredoc_delimiter>$
+    |
+    (?# Non-interpolated HEREDOC with leading spaces)
+    <<[-~]'\g<heredoc_delimiter>'[^\n]*+\n
+    (?:
+      (?!\s*\k<heredoc_delimiter>$)[^\n]*+\n
+    )*+
+    \s*\k<heredoc_delimiter>$
+    |
+    (?<!\w)\?.
+    |
+    (?# Consume characters that aren't string literals)
+    (?<=\w)\?
+    |
+    (?# A percentage sign that's not a percent literal)
+    %(?![qwisQWIrx]?+\g<percent_delimiter>)
+    )
+    |
+    (?# Consume angled brackets that aren't HEREDOCs)
+    <(?!<[~-]?['"a-zA-Z_])
+  /mx
+end

data/lib/rblade/railtie.rb

@@ -23,7 +23,7 @@ module RBlade
     end
 
     def setup_component_view_helper(mod)
-      mod.send(:define_method, RBlade.component_helper_method_name) do |component_name, current_view = nil, **attributes, &block|
+      mod.send(:define_method, RBlade.component_helper_method_name) do |component_name, current_view = nil, slot: "", **attributes, &block|
         # If this is a relative path, prepend with the previous component name's base
         if !current_view.nil? && component_name.start_with?(".")
           component_name = current_view.sub(/[^\.]++\z/, "") + component_name.delete_prefix(".")
@@ -37,12 +37,22 @@ module RBlade
         end
         path.sub!(/(?:\.[^.]++)?\.rblade\z/, "")
 
-        locals = {
-          slot: block.nil? ? attributes.delete(:slot) || -"" : capture(&block),
-          attributes: RBlade::AttributesManager.new(attributes),
-        }
+        attributes = RBlade::AttributesManager.new(attributes)
 
-        render template: path, locals:
+        unless block.nil?
+          value = nil
+          slot = @output_buffer.capture do
+            value = block.call(->(name, **slot_attributes, &slot_block) do
+              attributes[name] = RBlade::SlotManager.new(@output_buffer.capture(&slot_block), slot_attributes)
+            end)
+          end
+
+          if slot.blank?
+            slot = value || ""
+          end
+        end
+
+        render template: path, locals: {slot: RBlade::SlotManager.new(slot), attributes:}
       end
     end
   end

data/rblade.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "rblade"
-  s.version = "3.0.0"
+  s.version = "3.1.0"
   s.summary = "A component-first templating engine for Rails"
   s.description = "RBlade is a simple, yet powerful templating engine for Ruby on Rails, inspired by Laravel Blade."
   s.authors = ["Simon J"]
@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "minitest", "~> 5.0"
   s.add_development_dependency "minitest-reporters", "~> 1.1"
-  s.add_development_dependency "standard", ">= 1.3"
+  s.add_development_dependency "standard", ">= 1.35.1"
   s.add_development_dependency "rubocop", ">= 1.73"
   s.add_development_dependency "rails", ">= 7.0"
   s.add_development_dependency "benchmark-ips"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rblade
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Simon J
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-18 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.35.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.35.1
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -154,10 +154,10 @@ files:
 - lib/rblade/component_store.rb
 - lib/rblade/helpers/attributes_manager.rb
 - lib/rblade/helpers/class_manager.rb
+- lib/rblade/helpers/regular_expressions.rb
 - lib/rblade/helpers/slot_manager.rb
 - lib/rblade/helpers/stack_manager.rb
 - lib/rblade/helpers/style_manager.rb
-- lib/rblade/helpers/tokenizer.rb
 - lib/rblade/rails_template.rb
 - lib/rblade/railtie.rb
 - rblade.gemspec

data/lib/rblade/helpers/tokenizer.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RBlade
-  class Tokenizer
-    def self.extract_comma_separated_values(segment)
-      unless segment.match?(/,\s*+\z/)
-        # Add a comma to the end to delimit the end of the last argument
-        segment += ","
-      end
-      segment_lines = segment.lines
-
-      tokens = Ripper.lex segment
-      arguments = []
-
-      current_line = 1
-      current_index = 0
-      bracket_count = {
-        "[]": 0,
-        "{}": 0,
-        "()": 0,
-      }
-      tokens.each do |token|
-        case token[1]
-        when :on_lbracket
-          bracket_count[:[]] += 1
-        when :on_rbracket
-          bracket_count[:[]] -= 1
-        when :on_lbrace
-          bracket_count[:"{}"] += 1
-        when :on_rbrace
-          bracket_count[:"{}"] -= 1
-        when :on_lparen
-          bracket_count[:"()"] += 1
-        when :on_rparen
-          bracket_count[:"()"] -= 1
-        when :on_comma
-          if bracket_count[:[]] != 0 || bracket_count[:"{}"] != 0 || bracket_count[:"()"] != 0
-            next
-          end
-
-          argument = +""
-
-          # Concatenate all lines up to this token's line, including the tail end of the current line
-          if token[0][0] != current_line
-            (current_line...token[0][0]).each do |i|
-              argument << (segment_lines[i - 1].slice(current_index..-1) || "")
-              current_index = 0
-            end
-            current_line = token[0][0]
-          end
-          argument << segment_lines[current_line - 1].slice(current_index...token[0][1])
-          argument.strip!
-
-          arguments.push argument
-
-          current_index = token[0][1] + 1
-        end
-      end
-
-      return nil if arguments.count == 1 && arguments[0] == ""
-
-      arguments
-    end
-  end
-end