evc_rails 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7fda15b180ea02549511ff7aa2f1a51071ef8cce0fbf9721c92cc8fe4b6f605
-  data.tar.gz: 03ab565adcff81843d342152c4631c22124ee01d820e8a007a590afea3792347
+  metadata.gz: '08062fcb10857de4a7b864d324e705430a6eb3fe7712c2ed893a482dbbc1e604'
+  data.tar.gz: cbe0310f402b96fb62fae7a21647a149ec871539b476527615e72a1724402c79
 SHA512:
-  metadata.gz: c1b7c0694278f7bffbf73b23423f14ca96f993cdfd0f19fe230ce52014405d8f1221f0ff3922c9ae7fab2e889832d1de480b0465b875cfcb4cd6ad26c012fd34
-  data.tar.gz: 24c79d6ba0ac68acea62831ee0043bfb175ac05a3aab97cbe641b503258dfb4becabc21cc72b7f2b03bffdd8d68a0d88902dd9e82d79101e0c876cd28654f285
+  metadata.gz: a22db0b9bcd33d36b16908482b6eafc12cbbe684e588f9ab19dadeffdc6ac43672f8c026ed23a662cb7babe324abb0ca7d97195bc23a91d54c2f091225fcb472
+  data.tar.gz: 3445cef47452e7349d9ed6abe58dcdbe974d5c91097634fb5577ab0947cef60d863ff62e51e6cf457e2db73cb115e4a379f210d97d63b6785aee2eb0a454f9ce

data/README.md

@@ -1,201 +1,316 @@
-# EvcRails
+# EVC Rails
 
-EvcRails is a Rails gem that introduces a custom .evc template handler, allowing you to define your Rails View Components using a concise, HTML-like PascalCase tag syntax, reminiscent of React or other modern component-based UI frameworks. This gem seamlessly integrates your custom tags with Rails View Components, enabling a more declarative and readable approach to building UIs in Rails.
+Embedded ViewComponents (EVC) is a Rails template handler that brings JSX-like syntax to ViewComponent, allowing you to write PascalCase component tags directly in your `.evc` templates.
 
-## Features
+## Drop-in ERB Replacement
+
+EVC templates are a **drop-in replacement** for `.erb` files. All ERB features are fully supported:
+
+- `<%= %>` and `<% %>` tags
+- Ruby expressions and control flow
+- Helper methods (`link_to`, `form_with`, etc.)
+- Partials (`<%= render 'partial' %>`)
+- Layouts and content_for blocks
 
-PascalCase Component Tags: Define and use your View Components with <MyComponent> or self-closing <MyComponent /> syntax directly in your .evc templates.
+The template handler processes EVC syntax first, then passes the result to the standard ERB handler for final rendering.
 
-Namespaced Components: Support for namespaced components like <Ui::Button /> or <Forms::Input /> for better organization.
+## Works with Existing ViewComponents
 
-Attribute Handling: Pass attributes to your components using standard HTML-like key="value", key='value', or Ruby expressions key={@variable}.
+EVC works seamlessly with **any ViewComponents you already have** in `app/components`. Simply install the gem and start using easier syntax:
+
+```ruby
+# Your existing ViewComponent (no changes needed)
+class ButtonComponent < ViewComponent::Base
+  def initialize(variant: "default", size: "md")
+    @variant = variant
+    @size = size
+  end
+end
+```
 
-Content Blocks: Components can accept content blocks (<MyComponent>content</MyComponent>) which are passed to the View Component via a block.
+```html
+<!-- Now you can use it with EVC syntax -->
+<button variant="primary" size="lg">Click me</button>
+```
 
-Automatic Component Resolution: Automatically appends "Component" to your tag name if it's not already present (e.g., <Button> resolves to ButtonComponent, <Ui::Button> resolves to Ui::ButtonComponent).
+No component modifications required - just install and enjoy easier syntax!
 
-Performance Optimized: Includes in-memory caching of compiled templates and memoization of component class lookups for efficient rendering in production.
+## Features
+
+- **JSX-like syntax** for ViewComponent tags
+- **Self-closing components**: `<Button />`
+- **Block components**: `<Container>content</Container>`
+- **Attributes**: String, Ruby expressions, and multiple attributes
+- **Namespaced components**: `<UI::Button />`, `<Forms::Fields::TextField />`
+- **Slot support**: `<Card::Header>...</Card::Header>` with `renders_one` and `renders_many`
+- **Deep nesting**: Complex component hierarchies
+- **Production-ready caching** with Rails.cache integration
+- **Better error messages** with line numbers and column positions
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```
+```ruby
 gem 'evc_rails'
 ```
 
 And then execute:
 
-```
-bundle install
+```bash
+$ bundle install
 ```
 
-Or install it yourself as:
-
-```
-gem install evc_rails
-```
+The template handler will be automatically registered for `.evc` files.
 
 ## Usage
 
-1. Create a View Component
-   First, ensure you have a Rails View Component. For example, create app/components/my_component_component.rb:
+### Basic Components
 
-```ruby
-# app/components/my_component_component.rb
-class MyComponentComponent < ViewComponent::Base
-  def initialize(title:)
-    @title = title
-  end
+Create `.evc` files in your `app/views` directory:
 
-  def call
-    tag.div(class: "my-component") do
-      concat tag.h2(@title)
-      concat content # This renders the block content
-    end
-  end
-end
-```
+```html
+<!-- app/views/pages/home.evc -->
+<h1>Welcome to our app</h1>
 
-And its associated template app/components/my_component_component.html.erb (if you're using separate templates):
+<button size="lg" variant="primary">Get Started</button>
 
-```erb
-<!-- app/components/my_component_component.html.erb -->
-<div class="my-component">
-  <h2><%= @title %></h2>
-  <%= content %>
-</div>
+<Card>
+  <h2>Featured Content</h2>
+  <p>This is some amazing content.</p>
+</Card>
 ```
 
-2. Create an .evc Template
-   Now, create a template file with the .evc extension. For instance, app/views/pages/home.html.evc:
+This becomes:
 
 ```erb
-<!-- app/views/pages/home.html.evc -->
-<h1>Welcome to My App</h1>
-
-<MyComponent title="Hello World">
-  <p>This is some content passed to the component.</p>
-  <button text="Click Me" />
-</MyComponent>
-
-<%# Namespaced components for better organization %>
-<Ui::Button text="Click Me" />
-<Forms::Input name="email" placeholder="Enter your email" />
-<Layout::Container>
-  <p>Content inside a layout container</p>
-</Layout::Container>
+<h1>Welcome to our app</h1>
 
-<%# A more concise way to render your DoughnutChartComponent %>
-<DoughnutChart rings={@progress_data} />
+<%= render ButtonComponent.new(size: "lg", variant: "primary") do %>
+  Get Started
+<% end %>
 
-<%# You can still use standard ERB within .evc files %>
-<p><%= link_to "Go somewhere", some_path %></p>
+<%= render CardComponent.new do %>
+  <h2>Featured Content</h2>
+  <p>This is some amazing content.</p>
+<% end %>
 ```
 
-3. Ensure Components are Autoloaded
-   Make sure your app/components directory is eager-loaded in production. In config/application.rb or an initializer:
+### Self-Closing Components
 
-```ruby
-# config/application.rb
-config.eager_load_paths << Rails.root.join("app/components")
+```html
+<button />
+<Icon name="star" />
+<spacer height="20" />
 ```
 
-## Component Organization
+Becomes:
 
-You can organize your components into namespaces for better structure:
+```erb
+<%= render ButtonComponent.new %>
+<%= render IconComponent.new(name: "star") %>
+<%= render SpacerComponent.new(height: "20") %>
+```
+
+### Attributes
 
+#### String Attributes
+
+```html
+<button size="lg" variant="primary" />
 ```
-app/components/
-├── ui/
-│   ├── button_component.rb
-│   ├── card_component.rb
-│   └── input_component.rb
-├── forms/
-│   ├── input_component.rb
-│   ├── select_component.rb
-│   └── checkbox_component.rb
-├── layout/
-│   ├── container_component.rb
-│   ├── header_component.rb
-│   └── footer_component.rb
-└── my_component_component.rb
+
+#### Ruby Expressions
+
+```html
+<button user="{@current_user}" count="{@items.count}" />
 ```
 
-Then use them in your .evc templates:
+#### Multiple Attributes
 
-```erb
-<Ui::Button text="Submit" />
-<Forms::Input name="username" />
-<Layout::Container>
-  <Layout::Header title="My App" />
-  <p>Main content</p>
-  <Layout::Footer />
-</Layout::Container>
+```html
+<Card class="shadow-lg" data-testid="featured-card" user="{@user}">
+  Content here
+</Card>
 ```
 
-## How it Works
+### Namespaced Components
 
-When Rails processes an .evc template, EvcRails intercepts it and performs the following transformations:
+Organize your components in subdirectories:
 
-```erb
-<Card title="Hello World">... </Card>
+```html
+<UI::Button size="lg" />
+<Forms::Fields::TextField value="{@email}" />
+<Layout::Container class="max-w-4xl">
+  <UI::Card>Content</UI::Card>
+</Layout::Container>
 ```
 
-becomes:
+This maps to:
+
+- `app/components/ui/button_component.rb`
+- `app/components/forms/fields/text_field_component.rb`
+- `app/components/layout/container_component.rb`
+
+### Slot Support
+
+#### Single Slots (`renders_one`)
 
 ```ruby
-<%= render CardComponent.new(title: "Hello World") do %>
-  ... (processed content) ...
-<% end %>
+# app/components/card_component.rb
+class CardComponent < ViewComponent::Base
+  renders_one :header
+  renders_one :body
+end
+```
+
+```html
+<Card>
+  <Card::Header>
+    <h1>Welcome</h1>
+  </Card::Header>
+  <Card::Body>
+    <p>This is the body content.</p>
+  </Card::Body>
+</Card>
 ```
 
+Becomes:
+
 ```erb
-<Button text="Click Me" />
+<%= render CardComponent.new do |c| %>
+  <% c.header do %>
+    <h1>Welcome</h1>
+  <% end %>
+  <% c.body do %>
+    <p>This is the body content.</p>
+  <% end %>
+<% end %>
 ```
 
-becomes:
+#### Multiple Slots (`renders_many`)
 
 ```ruby
-<%= render ButtonComponent.new(text: "Click Me") %>
+# app/components/list_component.rb
+class ListComponent < ViewComponent::Base
+  renders_many :items
+end
 ```
 
+```html
+<List>
+  <List::Item>Item 1</List::Item>
+  <List::Item>Item 2</List::Item>
+  <List::Item>Item 3</List::Item>
+</List>
+```
+
+Becomes:
+
 ```erb
-<Ui::Button text="Click Me" />
+<%= render ListComponent.new do |c| %>
+  <% c.item do %>Item 1<% end %>
+  <% c.item do %>Item 2<% end %>
+  <% c.item do %>Item 3<% end %>
+<% end %>
+```
+
+### Complex Nesting
+
+```html
+<UI::Card>
+  <h2 class="text-2xl font-semibold">Dashboard</h2>
+
+  <UI::Grid cols="3" gap="md">
+    <UI::Card shadow="sm">
+      <p class="text-center">Widget 1</p>
+    </UI::Card>
+    <UI::Card shadow="sm">
+      <p class="text-center">Widget 2</p>
+    </UI::Card>
+    <UI::Card shadow="sm">
+      <p class="text-center">Widget 3</p>
+    </UI::Card>
+  </UI::Grid>
+</UI::Card>
 ```
 
-becomes:
+### Mixed Content
 
-```ruby
-<%= render Ui::ButtonComponent.new(text: "Click Me") %>
+You can mix regular HTML, ERB, and component tags:
+
+```html
+<div class="container">
+  <h1><%= @page.title %></h1>
+
+  <% if @show_featured %>
+  <FeaturedCard />
+  <% end %>
+
+  <div class="grid">
+    <% @posts.each do |post| %>
+    <PostCard post="{post}" />
+    <% end %>
+  </div>
+</div>
 ```
 
-```erb
-<DoughnutChart rings={@progress_data} />
+## Error Handling
+
+The template handler provides detailed error messages with line numbers and column positions:
+
+```
+ArgumentError: Unmatched closing tag </Button> at line 15, column 8
+ArgumentError: Unclosed tag <Card> at line 10, column 1
+ArgumentError: No matching opening tag for </Container> at line 20, column 5
+```
+
+## Caching
+
+Templates are automatically cached in production environments using `Rails.cache`. The cache is keyed by template identifier and source content hash, ensuring cache invalidation when templates change.
+
+### Cache Management
+
+Clear the template cache:
+
+```ruby
+Rails.cache.clear
 ```
 
-becomes:
+Or clear specific template patterns:
 
 ```ruby
-<%= render DoughnutChartComponent.new(rings: @progress_data) %>
+Rails.cache.delete_matched("evc_rails_template:*")
 ```
 
-`attr={@variable}` becomes `attr: @variable` in the new() call.
+## Development
+
+### Running Tests
 
-The transformed content is then passed to the standard ERB handler for final rendering.
+```bash
+bundle exec ruby test/unit/template_handler_test.rb
+```
 
-## Configuration
+### Building the Gem
 
-Currently, EvcRails requires no specific configuration. Future versions might include options for:
+```bash
+gem build evc_rails.gemspec
+```
 
-Customizing the component suffix (e.g., if you don't want "Component" appended).
+## Requirements
 
-Defining custom component lookup paths.
+- Rails 6.0+
+- Ruby 3.1+
+- ViewComponent 2.0+
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [your-gem-repo-link]. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the code of conduct.
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
 
 ## License
 
-The gem is available as open source under the terms of the MIT License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/evc_rails/railtie.rb

@@ -3,27 +3,23 @@
 # This file defines a Rails::Railtie, which integrates the evc_rails gem
 # with the Rails framework during its boot process.
 
-require "evc_rails/template_handler"
+require_relative "template_handler"
 require "action_view" # Ensure ActionView is loaded for handler registration
 
 module EvcRails
   class Railtie < Rails::Railtie
     # Register MIME type and template handler early in the initialization process
     initializer "evc_rails.register_template_handler", before: :load_config_initializers do
-      Rails.logger.info "Registering EVC template handler"
       # Register a unique MIME type for .evc templates
       Mime::Type.register "text/evc", :evc, %w[text/evc], %w[evc]
 
       # Register the template handler
       handler = EvcRails::TemplateHandlers::Evc.new
       ActionView::Template.register_template_handler(:evc, handler)
-
-      Rails.logger.info "Template handler registered: #{handler.inspect}"
     end
 
     # Finalize configuration after Rails initialization
     config.after_initialize do
-      Rails.logger.info "Configuring EVC template handlers"
       # Ensure :evc is prioritized in default handlers
       config.action_view.default_template_handlers ||= []
       config.action_view.default_template_handlers.prepend(:evc)

data/lib/evc_rails/template_handler.rb

@@ -1,195 +1,256 @@
 # lib/evc_rails/template_handler.rb
 #
-# This file contains the core logic for the .evc template handler.
-# It's part of the `EvcRails` module to keep it namespaced within the gem.
-# Handles .evc templates, converting PascalCase tags (self-closing <MyComponent attr={value} />
-# or container <MyComponent>content</MyComponent>) into Rails View Component renders.
-# Supports string literals and Ruby expressions as attribute values. The handler is
-# agnostic to specific component APIs, passing content as a block for the component
-# to interpret via yield or custom methods.
+# Simple template handler for .evc files
+# Converts PascalCase tags into Rails View Component renders
 
 module EvcRails
   module TemplateHandlers
     class Evc
-      # Regex to match opening or self-closing PascalCase component tags with attributes
-      # Updated to support namespaced components like UI::Button
-      TAG_REGEX = %r{<([A-Z][a-zA-Z_]*(::[A-Z][a-zA-Z_]*)*)([^>]*)/?>}
-
-      # Regex to match closing PascalCase component tags
-      # Updated to support namespaced components like UI::Button
-      CLOSE_TAG_REGEX = %r{</([A-Z][a-zA-Z_]*(::[A-Z][a-zA-Z_]*)*)>}
-
-      # Regex for attributes: Supports string literals (key="value", key='value')
-      # and Ruby expressions (key={@variable}).
-      # Group 1: Attribute key, Group 2: Double-quoted value, Group 3: Single-quoted value,
-      # Group 4: Ruby expression.
+      # Simple regex to match PascalCase component tags
+      TAG_REGEX = %r{<([A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)([^>]*)/?>}
+
+      # Regex to match closing tags
+      CLOSE_TAG_REGEX = %r{</([A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)>}
+
+      # Regex for attributes
       ATTRIBUTE_REGEX = /(\w+)=(?:"([^"]*)"|'([^']*)'|\{([^}]*)\})/
 
-      # Cache for compiled templates to improve performance.
-      # @cache will store { identifier: { source: original_source, result: compiled_result } }
-      # Note: In a production environment, a more robust cache store (e.g., Rails.cache)
-      # might be preferred for persistence and memory management, especially for large applications.
-      # This simple in-memory cache is effective for a single process.
-      @cache = {}
+      # Cache for compiled templates
+      @template_cache = {}
+      @cache_mutex = Mutex.new
+
+      require "active_support/cache"
 
-      def self.clear_cache # Class method to allow clearing cache manually, if needed
-        @cache = {}
+      def self.clear_cache
+        @cache_mutex.synchronize do
+          @template_cache.clear
+        end
+      end
+
+      def self.cache_stats
+        @cache_mutex.synchronize do
+          {
+            size: @template_cache.size,
+            keys: @template_cache.keys
+          }
+        end
+      end
+
+      def cache_store
+        if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+          Rails.cache
+        else
+          @fallback_cache ||= ActiveSupport::Cache::MemoryStore.new
+        end
       end
 
       def call(template, source = nil)
-        identifier = template.identifier
-
-        # Only use cache in non-development environments
-        # Check if cache exists for this template and if the source hasn't changed.
-        # This prevents recompilation of unchanged templates.
-        if !Rails.env.development? && self.class.instance_variable_get(:@cache)[identifier] &&
-           source == self.class.instance_variable_get(:@cache)[identifier][:source]
-          return self.class.instance_variable_get(:@cache)[identifier][:result]
+        source ||= template.source
+
+        # Check cache first (only in non-development environments)
+        unless Rails.env.development?
+          cache_key = "evc_rails_template:#{template.identifier}:#{Digest::MD5.hexdigest(source)}"
+          cached_result = cache_store.read(cache_key)
+          return cached_result if cached_result
         end
 
-        # Process the template source into an ERB-compatible string
+        # Process the template and convert to ERB
         processed_source = process_template(source, template)
 
-        # Get the standard ERB handler and pass the processed source to it
+        # Use the standard ERB handler to compile the processed source
         erb_handler = ActionView::Template.registered_template_handler(:erb)
         result = erb_handler.call(template, processed_source)
 
-        # Cache the result for future requests, but only in non-development environments.
-        # In development, templates change frequently, so caching would hinder development flow.
+        # Cache the result (only in non-development environments)
         unless Rails.env.development?
-          self.class.instance_variable_set(:@cache, self.class.instance_variable_get(:@cache).merge({
-                                                                                                      identifier => { source: source, result: result }
-                                                                                                    }))
+          cache_key = "evc_rails_template:#{template.identifier}:#{Digest::MD5.hexdigest(source)}"
+          cache_store.write(cache_key, result)
         end
-        result
+
+        normalize_whitespace(result)
       end
 
       private
 
-      # A memoization cache for resolved component classes within a single template processing.
-      # This prevents repeated `constantize` calls for the same component name within `process_template`.
-      attr_reader :component_class_memo
-
-      def initialize
-        @component_class_memo = {}
-      end
-
-      # Processes the .evc template source, converting custom tags into Rails View Component render calls.
-      # This method is recursive to handle nested components.
       def process_template(source, template)
-        # Using an array for `parts` and then joining at the end is generally more efficient
-        # for building strings in Ruby than repeated string concatenations (`<<`).
-        parts = []
+        # Pre-compile regexes for better performance
+        tag_regex = TAG_REGEX
+        close_tag_regex = CLOSE_TAG_REGEX
+        attribute_regex = ATTRIBUTE_REGEX
+
+        # Use String buffer for better performance
+        result = String.new
+        stack = []
         pos = 0
-        stack = [] # Track [component_class_name, render_params_str, start_pos_in_source]
+        source_length = source.length
 
-        # Initialize memoization cache for this processing run
-        @component_class_memo = {}
+        # Track line numbers for better error messages
+        def line_number_at_position(source, pos)
+          source[0...pos].count("\n") + 1
+        end
 
-        while pos < source.length
-          # Try to match an opening or self-closing tag
-          if (match = TAG_REGEX.match(source, pos))
-            # Append text before the current tag to the result parts
-            parts << source[pos...match.begin(0)]
-            pos = match.end(0) # Move position past the matched tag
+        def column_number_at_position(source, pos)
+          last_newline = source[0...pos].rindex("\n")
+          last_newline ? pos - last_newline : pos + 1
+        end
 
-            is_self_closing = match[0].end_with?("/>")
-            tag_name = match[1]
-            attributes_str = match[3].strip
-
-            # Determine the full component class name
-            # Handle both namespaced (UI::Button) and non-namespaced (Button) components
-            component_class_name = if tag_name.include?("::")
-                                     # For namespaced components, just append Component
-                                     "#{tag_name}Component"
-                                   elsif tag_name.end_with?("Component")
-                                     tag_name
-                                   else
-                                     "#{tag_name}Component"
-                                   end
-
-            # Validate if the component class exists using memoization.
-            # The component class will only be constantized once per unique class name
-            # within a single template processing call.
-            component_class = @component_class_memo[component_class_name] ||= begin
-              component_class_name.constantize
-            rescue NameError
-              raise ArgumentError, "Component #{component_class_name} not found in template #{template.identifier}"
-            end
+        while pos < source_length
+          # Find next opening or closing tag
+          next_open = tag_regex.match(source, pos)
+          next_close = close_tag_regex.match(source, pos)
 
-            # Parse attributes and format them for the render call
-            params = []
-            attributes_str.scan(ATTRIBUTE_REGEX) do |key, quoted_value, single_quoted_value, ruby_expression|
-              # Basic validation for attribute keys
-              unless key =~ /\A[a-z_][a-z0-9_]*\z/i
-                raise ArgumentError, "Invalid attribute key '#{key}' in template #{template.identifier}"
-              end
+          if next_open && (!next_close || next_open.begin(0) < next_close.begin(0))
+            # Found opening tag
+            match = next_open
+            tag_name = match[1]
+            attributes_str = match[2].to_s.strip
+            is_self_closing = match[0].end_with?("/>")
 
-              formatted_key = "#{key}:"
-              if ruby_expression
-                # For Ruby expressions, directly embed the expression.
-                params << "#{formatted_key} #{ruby_expression}"
-              elsif quoted_value
-                # For double-quoted string literals, escape double quotes within the value.
-                params << "#{formatted_key} \"#{quoted_value.gsub('"', '\"')}\""
-              elsif single_quoted_value
-                # For single-quoted string literals, escape single quotes within the value
-                # and wrap in double quotes for Ruby string literal syntax.
-                params << "#{formatted_key} \"#{single_quoted_value.gsub("'", "\\'")}\""
+            # Add content before the tag
+            result << source[pos...match.begin(0)] if pos < match.begin(0)
+
+            # Determine if this is a slot (e.g., Card::Header inside Card)
+            parent = stack.last
+            is_slot = false
+            slot_name = nil
+            slot_parent = nil
+            if parent
+              parent_tag = parent[0]
+              if tag_name.start_with?("#{parent_tag}::")
+                is_slot = true
+                slot_name = tag_name.split("::").last.downcase
+                slot_parent = parent_tag
+                # Mark parent as having a slot
+                parent[6] = true
               end
             end
 
-            render_params_str = params.join(", ")
-
             if is_self_closing
-              # If it's a self-closing tag, generate a simple render call.
-              parts << "<%= render #{component_class_name}.new(#{render_params_str}) %>"
+              if is_slot
+                params = parse_attributes(attributes_str, attribute_regex)
+                param_str = params.join(", ")
+                result << if param_str.empty?
+                            "<% c.#{slot_name} do %><% end %>"
+                          else
+                            "<% c.#{slot_name}(#{param_str}) do %><% end %>"
+                          end
+              else
+                component_class = "#{tag_name}Component"
+                params = parse_attributes(attributes_str, attribute_regex)
+                param_str = params.join(", ")
+                result << if param_str.empty?
+                            "<%= render #{component_class}.new %>"
+                          else
+                            "<%= render #{component_class}.new(#{param_str}) %>"
+                          end
+              end
+            elsif is_slot
+              params = parse_attributes(attributes_str, attribute_regex)
+              param_str = params.join(", ")
+              stack << [tag_name, nil, param_str, result.length, :slot, slot_name, false, match.begin(0)]
+              result << if param_str.empty?
+                          "<% c.#{slot_name} do %>"
+                        else
+                          "<% c.#{slot_name}(#{param_str}) do %>"
+                        end
             else
-              # If it's an opening tag, push it onto the stack to await its closing tag.
-              stack << [component_class_name, render_params_str, pos]
+              component_class = "#{tag_name}Component"
+              params = parse_attributes(attributes_str, attribute_regex)
+              param_str = params.join(", ")
+              # If this is the outermost component, add |c| for slot support only if a slot is used
+              if stack.empty?
+                stack << [tag_name, component_class, param_str, result.length, :component, nil, false, match.begin(0)] # [tag_name, class, params, pos, type, slot_name, slot_used, open_pos]
+                # We'll patch in |c| at close if needed
+                result << if param_str.empty?
+                            "<%= render #{component_class}.new do %>"
+                          else
+                            "<%= render #{component_class}.new(#{param_str}) do %>"
+                          end
+              else
+                stack << [tag_name, component_class, param_str, result.length, :component, nil, false, match.begin(0)]
+                result << if param_str.empty?
+                            "<%= render #{component_class}.new do %>"
+                          else
+                            "<%= render #{component_class}.new(#{param_str}) do %>"
+                          end
+              end
             end
 
-          # Try to match a closing tag
-          elsif (match = CLOSE_TAG_REGEX.match(source, pos))
-            # Append text before the closing tag to the result parts
-            parts << source[pos...match.begin(0)]
-            pos = match.end(0) # Move position past the matched tag
-
+            pos = match.end(0)
+          elsif next_close
+            # Found closing tag
+            match = next_close
             closing_tag_name = match[1]
 
-            # Check for unmatched closing tags
+            # Add content before the closing tag
+            result << source[pos...match.begin(0)] if pos < match.begin(0)
+
+            # Find matching opening tag
             if stack.empty?
-              raise ArgumentError, "Unmatched closing tag </#{closing_tag_name}> in template #{template.identifier}"
+              line = line_number_at_position(source, match.begin(0))
+              col = column_number_at_position(source, match.begin(0))
+              raise ArgumentError, "Unmatched closing tag </#{closing_tag_name}> at line #{line}, column #{col}"
             end
 
-            # Pop the corresponding opening tag from the stack
-            component_class_name, render_params_str, start_pos = stack.pop
-
-            # Check for mismatched tags (e.g., <div></p>)
-            if component_class_name != closing_tag_name
-              raise ArgumentError,
-                    "Mismatched tags: expected </#{component_class_name}>, got </#{closing_tag_name}> in template #{template.identifier}"
+            # Find the matching opening tag (from the end)
+            matching_index = stack.rindex { |(tag_name, _, _, _, _, _, _, _)| tag_name == closing_tag_name }
+            if matching_index.nil?
+              line = line_number_at_position(source, match.begin(0))
+              col = column_number_at_position(source, match.begin(0))
+              raise ArgumentError, "No matching opening tag for </#{closing_tag_name}> at line #{line}, column #{col}"
             end
 
-            # Recursively process the content between the opening and closing tags.
-            # This is where nested components are handled.
-            content = process_template(source[start_pos...match.begin(0)], template)
+            # Pop the matching opening tag
+            tag_name, component_class, param_str, start_pos, type, slot_name, slot_used, open_pos = stack.delete_at(matching_index)
 
-            # Generate the render call with a block for the content.
-            parts << "<%= render #{component_class_name}.new(#{render_params_str}) do %>#{content}<% end %>"
+            # Patch in |c| for top-level component if a slot was used
+            if type == :component && stack.empty? && slot_used
+              # Find the opening block and insert |c|
+              open_block_regex = /(<%= render #{component_class}\.new(?:\(.*?\))? do)( %>)/
+              result.sub!(open_block_regex) { "#{::Regexp.last_match(1)} |c|#{::Regexp.last_match(2)}" }
+            end
+
+            # Add closing block
+            result << (type == :slot ? "<% end %>" : "<% end %>")
 
+            pos = match.end(0)
           else
-            # If no tags are matched, append the rest of the source and break the loop.
-            parts << source[pos..-1]
+            # No more tags, add remaining content
+            result << source[pos..-1] if pos < source_length
             break
           end
         end
 
-        # After parsing, if the stack is not empty, it means there are unclosed tags.
-        raise ArgumentError, "Unclosed tag <#{stack.last[0]}> in template #{template.identifier}" unless stack.empty?
+        # Check for unclosed tags
+        unless stack.empty?
+          unclosed_tag = stack.last
+          open_pos = unclosed_tag[7]
+          line = line_number_at_position(source, open_pos)
+          col = column_number_at_position(source, open_pos)
+          raise ArgumentError, "Unclosed tag <#{unclosed_tag[0]}> at line #{line}, column #{col}"
+        end
+
+        result
+      end
+
+      def normalize_whitespace(erb_string)
+        # For now, return the string as-is to avoid breaking existing functionality
+        # We can add proper whitespace normalization later if needed
+        erb_string
+      end
 
-        # Join all the collected parts to form the final ERB string.
-        parts.join("")
+      def parse_attributes(attributes_str, attribute_regex = ATTRIBUTE_REGEX)
+        params = []
+        attributes_str.scan(attribute_regex) do |key, quoted_value, single_quoted_value, ruby_expression|
+          if ruby_expression
+            params << "#{key}: #{ruby_expression}"
+          elsif quoted_value
+            params << "#{key}: \"#{quoted_value.gsub('"', '\\"')}\""
+          elsif single_quoted_value
+            params << "#{key}: \"#{single_quoted_value.gsub("'", "\\'")}\""
+          end
+        end
+        params
       end
     end
   end

data/lib/evc_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EvcRails
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: evc_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - scttymn
@@ -90,7 +90,6 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/scttymn/evc_rails
   source_code_uri: https://github.com/scttymn/evc_rails
-  changelog_uri: https://github.com/scttymn/evc_rails/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib