slotify 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9401d13b9a845572abccc1cd38362bb6facfb5394568a74345d856abc6db80ea
-  data.tar.gz: bd8c9df4efe6ee8d40d7967f06326b9950d160c824828c11537f5c44f63f200c
+  metadata.gz: 3528c82a3e01b2acc454f5df4c8081f19157e975a2e2ddaa46f56dadc565426f
+  data.tar.gz: e9660ecb767e9ec12156eb3e878f10cdf9fe74c8b67b9fbc574fa64cae1f5f1a
 SHA512:
-  metadata.gz: 1af7661c421919e5bc90069a75781075e27b9f97d1d767148f5ece3abe773dc1b206ea59435e511c7e1b1805a34124b19b4e1d8354fc7cf70e27dfbcd4e7445a
-  data.tar.gz: 2c3f889e7f55d65af6be315c9b013a21ab63b8cee3c9304cf3ebd947b3324c899c0830e5ea420d1aac7bda0d54603fe69d97eb87fdc765c1a8c0f8f70ec9af69
+  metadata.gz: fe68d4ff07cbc1a12cc69937bb0da7af4080082504226f7dd9c63a8f4b35461460671265ca09745a9899e6e49ac5aab0c377a83d795a2547eb423255907aa84d
+  data.tar.gz: a189cd09e36a1eab05de32a1c62f953acbe72dcca1ed64c0dd058002ded2f8da2d828e95e0ba0b7865a29d3cac4c58a1cc9c7ad45679ce87684a8edfe03e1032

data/README.md

@@ -1,27 +1,28 @@
 <img src=".github/assets/slotify_wordmark.svg" width="200">
 
+<p><a href="https://rubygems.org/gems/slotify"><img src="https://img.shields.io/gem/v/slotify" alt="Gem version"></a>
+<a href="https://github.com/allmarkedup/slotify/actions/workflows/ci.yml"><img src="https://github.com/allmarkedup/slotify/actions/workflows/ci.yml/badge.svg" alt="CI status"></a></p>
 
+## Superpowered slots for ActionView partials
 
-### Superpowered slots for ActionView partials
-
----
-
-## Overview 
-
-Slotify adds an unobtrusive (but powerful!) **content slot API** to ActionView partials.
+Slotify adds an unobtrusive (but powerful!) **content slot API** to ActionView partials. 
 
 Slots are a convenient way to pass blocks of content in to a partial without having to resort to ugly `<% capture do ... end %>` workarounds or unscoped (global) `<% content_for :foo %>` declarations.
 
 Slotified partials are a great way to build components in a Rails app without the additional overhead and learning curve of libraries like [ViewComponent](https://viewcomponent.org/) or [Phlex](https://www.phlex.fun/).
 
+> [!CAUTION]
+> Slotify is still in a early stage of development.
+The documentation is still quite sparse and the API could change at any point prior to a `v1.0` release.
+
 ### 
 
 ## Slotify basics
 
-Slotify slots are defined using a **[strict locals](https://guides.rubyonrails.org/action_view_overview.html#strict-locals)-style magic comment** at the top of partial templates ([more details here](#defining-slots)).
+Slotify slots are defined using a **[strict locals](https://guides.rubyonrails.org/action_view_overview.html#strict-locals)-style magic comment** at the top of **partial templates** ([more details here](#defining-slots)).
 
 ```erb
-<%# slots: (slot_name: "default value", optional_slot_name: nil, required_slot_name:) -%>
+<%# slots: (title:, body: nil, theme: "default") -%>
 ```
 
 Slot content is accessed via **standard local variables** within the partial. So a simple, slot-enabled `article` partial template might look something like this:
@@ -29,10 +30,10 @@ Slot content is accessed via **standard local variables** within the partial. So
 ```erb
 <!-- _article.html.erb -->
 
-<%# slots: (heading: "Default title", body: nil) -%>
+<%# slots: (title: "Default title", body: nil) -%>
 
 <article>
-  <h1><%= heading %></h1>
+  <h1><%= title %></h1>
   <% if body.present? %>
     <div>
       <%= body %>
@@ -46,11 +47,11 @@ Slot content is accessed via **standard local variables** within the partial. So
 
 When the partial is rendered, a special `partial` object is yielded as an argument to the block. Slot content is set by calling the appropriate `#with_<slot_name>` methods on this partial object.
 
-For example, here our `article` partial is being rendered with content for the `heading` and `body` slots that were defined above:
+For example, here our `article` partial is being rendered with content for the `title` and `body` slots that were defined above:
 
 ```erb
 <%= render "article" do |partial| %>
-  <% partial.with_heading "This is a title" %>
+  <% partial.with_title "This is a title" %>
   <% partial.with_body do %>
     <p>You can use <%= tag.strong "markup" %> within slot content blocks without
       having to worry about marking the output as <code>html_safe</code> later.</p>
@@ -61,7 +62,82 @@ For example, here our `article` partial is being rendered with content for the `
 > [!NOTE]
 > _If you've ever used [ViewComponent](https://viewcomponent.org) then the above code should also feel quite familiar to you - it's pretty much the same syntax used to provide content to [component slots](https://viewcomponent.org/guide/slots.html)._
 
-But this example just scratches the surface of what Slotify slots can do! Read on to learn more (or [jump to a more full-featured example here](#full-example)).
+But this example just scratches the surface of what Slotify slots can do. Have a look at the more full-featured example below or jump to [the usage information](#usage).
+
+<details>
+<summary><h4>More full-featured example</h4></summary>
+
+```erb
+<!-- views/_example.html.erb -->
+
+<%# locals: (id:) -%>
+<%# slots: (title: "Example title", lists: nil, quotes: nil, website_link:) -%>
+
+<%= tag.section id: do %>
+  <h1 class="example-title">
+    <%= title %>
+  </h1>
+  
+  <p>Example link: <%= link_to website_link, data: {controller: "external-link"} %></p>
+
+  <%= render lists, title: "Default title" %>
+
+  <% if quotes.any? %>
+    <h3>Quotes</h3>
+    <% quotes.each do |quote| %>
+      <blockquote <%= quote.options.except(:citation) %>>
+        <%= quote %>
+        <%== "&mdash; #{tag.cite(quote.options.citation)}" if quote.options.citation.present? %>
+      </blockquote>
+    <% end %>
+  <% end %>
+<% end %>
+```
+
+```erb
+<!-- views/_list.html.erb -->
+
+<%# locals: (title:) -%>
+<%# slots: (items: nil) -%>
+ 
+<h3><%= title %></h3>
+
+<% if items.any? %>
+  <%= tag.ul class: "list" do %>
+    <%= content_tag :li, items, class: "list-item" %>
+  <% end %>
+<% end %>
+```
+
+```erb
+<!-- views/slotify.html.erb -->
+
+<%= render "example", id: "slotify-example" do |partial| %>
+  <% partial.with_subtitle do %>
+    This is the <%= tag.em "subtitle" %>
+  <% end %>
+
+  <% partial.with_website_link "example.com", "https://example.com", target: "_blank", data: {controller: "preview-link"} %>
+
+  <% partial.with_list do |list| %>
+    <% list.with_item "first thing" %> 
+    <% list.with_item "second thing", class: "text-green-700" %>
+    <% list.with_item "third thing" %>
+  <% end %>
+
+  <% partial.with_quote citation: "A. Person", class: "text-lg" do %>
+    <p>Lorem ipsum dolor sit amet consectetur adipisicing elit.</p>
+  <% end %>
+
+  <% partial.with_quote do %>
+    <p>Non quos explicabo eius hic quaerat laboriosam incidunt numquam.</p>
+  <% end %>
+<% end %>
+```
+
+</details>
+
+---
 
 ## Usage
 
@@ -71,7 +147,7 @@ But this example just scratches the surface of what Slotify slots can do! Read o
 Slots are defined using a [strict locals](https://guides.rubyonrails.org/action_view_overview.html#strict-locals)-style magic comment at the top of the partial template. The `slots:` signature uses the same syntax as standard Ruby method signatures:
 
 ```erb
-<%# slots: (title:, summary: "No summary available", author: nil) -%>
+<%# slots: (title:, body: "No content available", author: nil) -%>
 ```
 
 #### Required slots
@@ -110,11 +186,11 @@ either above or below the `slots` definition.
 <!-- _article.html.erb -->
 
 <%# locals: (title:) -%>
-<%# slots: (summary: "No summary available") -%>
+<%# slots: (body: "No content available") -%>
 
 <article>
   <h1><%= title %></h1>
-  <div><%= summary %></div>
+  <div><%= body %></div>
 </article>
 ```
 
@@ -122,28 +198,72 @@ Locals are provided when rendering the partial in the usual way.
 
 ```erb
 <%= render "article", title: "Article title here" do |partial| %>
-  <% partial.with_summary do %>
-    <p>Summary content here...</p>
+  <% partial.with_body do %>
+    <p>Body content here...</p>
   <% end %>
 <% end %>
 ```
 
-### Slot content and options
+### Setting slot values
 
-Content is passed into slots using dynamically generated `partial#with_<slot_name>` methods.
+Content is passed into slots using dynamically generated `partial#with_<slot_name>` writer methods.
 
 Content can be provided as either the **first argument** or **as a block** when calling these methods at render time.
-The following `#with_title` calls are both equivalent:
+The following two examples are equivalent:
 
 ```erb
 <%= render "example" do |partial| %>
   <% partial.with_title "Title passed as argument" %>
+<% end %>
+```
+
+```erb
+<%= render "example" do |partial| %>
   <% partial.with_title do %>
     Title passed as block content
   <% end %>
 <% end %>
 ```
 
+> [!TIP]
+> Block content is generally better suited for longer-form content containing HTML tags because it will not need to be marked
+as `html_safe` when used in the partial template.
+
+The content will be available as a local variable in the partial template whichever way it is provided.
+
+```erb
+<%# slots: (title:) -%>
+<h1><%= title %></h1> 
+```
+
+### Slot options
+
+The slot value writer methods also accept optional arbitrary keyword arguments.
+These can then be accessed in the partial template via the `.options` method on the slot variable.
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_title "The title", class: "color-hotpink", data: {controller: "fancy-title"} %>
+<% end %>
+```
+
+```erb
+<%# slots: (title:) -%>
+
+<%= title.options.keys %> <!-- [:class, :data] -->
+<%= title %> <!-- The title -->
+```
+
+Slot options can be useful for providing tag attributes when rendering slot content or rendering variants
+of a slot based on an option value.
+
+When rendered as a string the options are passed through the Rails `tag.attributes` helper to generate an HTML tag attributes string:
+
+```erb
+<h1 <%= title.options %>><%= title %></h1> 
+<!-- <h1 class="color-hotpink" data-controller="fancy-title">The title</h1> -->
+```
+
 ### Slot types
 
 There are two types of slots.
@@ -194,7 +314,9 @@ Multiple-value slots are defined using a **plural** slot name:
 ```
 
 Multiple-value slots can be called as many times as needed
-and their corresponding template variable represents an array of values:
+and their corresponding template variable represents an array of values.
+
+The slot writer methods for multiple-value slots use the **singluar form** of the slot name (e.g. `#with_item` for the `items` slot).
 
 ```erb
 <%= render "example" do |partial| %>
@@ -218,17 +340,134 @@ and their corresponding template variable represents an array of values:
 </ul>
 ```
 
-### Passing slot content to helpers
+### Using slots with helpers
 
 > _Docs coming soon..._ 
 
+```erb
+<% partial.with_title "The title", class: "color-hotpink" %>
+<% partial.with_website_link "Example website", "https://example.com", data: {controller: "external-link"} %>
+
+<% partial.with_item "Item one" %>
+<% partial.with_item "Item two", class: "highlight" %>
+```
+
+```erb
+<%= content_tag :h1, title %> <!-- <h1 class="color-hotpink">The title</h1> -->
+<%= content_tag :h1, title, class: "example-title" %> <!-- <h1 class="example-title color-hotpink">The title</h1> -->
+
+<%= link_to website_link %> <!-- <a href="https://example.com" data-controller="external-link">Example website</a> -->
+
+<%= content_tag :li, items %> <!-- <li>Item one</li><li class="highlight">Item two</li> -->
+<%= content_tag :li, items, class: "item" %> <!-- <li class="item">Item one</li><li class="item highlight">Item two</li> -->
+```
+
 ### Rendering slots
 
 > _Docs coming soon..._ 
 
-### Slot value objects
+### Slot values API
 
-> _Docs coming soon..._ 
+**Singlular slot value variables** in partial templates are actually instances of `Slotity::Value`.
+These value objects are automatically stringified so in most cases you will not even be aware of this and they can just be treated as regular string variables.
+
+
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_title class: "color-hotpink" do %>
+    The title
+  <% end %>
+<% end %>
+```
+
+```erb
+<% title.is_a?(Slotify::Value) %> <!-- true -->
+<% items.is_a?(Slotify::ValueCollection) %> <!-- true -->
+
+<%= title %> <!-- "The title" -->
+<% title.content %> <!-- "The title" -->
+
+<% title.options %> <!-- { class: "color-hotpink" } (hash of any options provided when calling the `.with_title` slot value writer method) -->
+<%= title.options %> <!-- "class='color-hotpink'" (string generated by passing the options hash through the Rails `tag.attributes` helper) -->
+```
+
+**Plural slot value variables** in partial templates are instances of the enumerable `Slotify::ValueCollection` class, with all items instances of `Slotity::Value`.
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+  <% partial.with_item "Item two", class: "current" %>
+<% end %>
+```
+
+```erb
+<% items.is_a?(Slotify::ValueCollection) %> <!-- true -->
+
+<% items.each do |item| %>
+  <li <%= item.options %>><%= item %></li>
+<% end %>
+<!-- <li>Item one</li> <li class="current">Item two</li> -->
+
+<%= items %> <!-- "Item one Item two" -->
+```
+
+#### `Slotity::Value`
+
+The following methods are available on `Slotity::Value` instances:
+
+**`.content`**
+
+Returns the slot content string that was provided as the first argument or as the block when calling the slot writer method.
+
+**`.options`**
+
+Returns a `Slotify::ValueOptions` instance that can be treated like a `Hash`. Calling `.slice` or `.except` on this will return another `Slotify::ValueOptions` instance.
+
+When converted to a string either explicitly (via `.to_s`) or implicitly (by outputting the value template using ERB `<%= %>` expression tags) the stringified value is generated by passing the options hash through the Rails `tag.attributes` helper.
+
+**`.with_default_options(default_options)`**
+
+Merges the options set when calling the slot value writer method with the `default_options` hash provided and returns a new `Slotity::Value` instance with the merged options set.
+
+```erb
+<% title_with_default_opts = title.with_default_options(class: "size-lg", aria: {level: 1}) %> <!-- apply default options -->
+
+<% title_with_default_opts.options %> <!-- { class: "size-lg color-hotpink", aria: {level: 1} } -->
+<%= title_with_default_opts.options %> <!-- "class='size-lg color-hotpink' aria-level='1'" -->
+```
+
+## Slotify vs alternatives
+
+#### `nice_partials`
+
+Slotify was very much inspired by the [Nice Partials gem](https://github.com/bullet-train-co/nice_partials) and both provide similar functionality.
+However there are a number of key differences:
+
+* Slotify requires the explicit definition of slots using 'strict locals'-style comments;
+Nice partials slots are implicitly defined when rendering the partial.
+* Slotify slot values are available as local variables;
+with Nice partials slot values are accessed via methods on the `partial` variable.
+* Slotify has the concept (and enforces the use) of single-value vs. multiple-value slots.
+* Slotify slot content and options are transparently expanded and merged into defaults when using with helpers like `content_tag` and `link_to`.
+* Slotify slot values are `renderable` objects
+
+You might choose slotify if you prefer a stricter, 'Rails-native'-feeling slots implementation, and Nice Partials if you want more render-time flexibility and a clearer
+separation of 'nice partial' functionality from ActionView-provided locals etc.
+
+#### `view_component`
+
+Both [ViewComponent](https://viewcomponent.org/) and Slotify provide a 'slots' API for content blocks.
+Slotify's slot writer syntax (i.e. `.with_<slot_name>` methods) and the concept of single-value (`renders_one`) vs multiple-value (`renders_many`) slots
+are both modelled on ViewComponent's slots implementation.
+
+However apart from that they are quite different. Slotify adds functionality to regular ActionView partials whereas ViewComponent provides a complete standalone component system.
+
+Each ViewComponent has an associated class which can be used to extract and encapsulate view logic.
+Slotify doesn't have an analagous concept, any view-specific logic will by default live in the partial template (as per standard partial rendering patterns). 
+
+You might choose Slotify if you want a more 'component-y' API but you don't want the overhead or learning curve associated with a tool that sits somewhat adjacent to the standard Rails way of doing things.
+But if you have components with a lot of view logic or want a more formalised component format then ViewComponent is likely a better fit for your project.
 
 ## Installation
 
@@ -251,78 +490,72 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
 
 `nice_partials` provides very similar functionality to Slotify but takes a slightly different approach/style. So if you are not convinced by Slotify then definitely [check it out](https://github.com/bullet-train-co/nice_partials)!
 
---- 
+## Benchmarks
 
-<a name="full-example" id="full-example"></a>
+Slotify is still in the early stages of development and no attempt has yet been made to optimise rendering performance.
 
-## A more full-featured example
+Below are some initial (crude) benchmarking comparisons with other similar gems.
 
-```erb
-<!-- views/_example.html.erb -->
+> [!TIP]
+> Benchmarks can be run using the `bin/benchmarks` command from the repository root.
 
-<%# locals: (id:) -%>
-<%# slots: (title: "Example title", lists: nil, quotes: nil, website_link:) -%>
+```
+✨🦄 ACTION_VIEW 🦄✨
 
-<%= tag.section id: do %>
-  <h1 class="example-title">
-    <%= title %>
-  </h1>
-  
-  <p>Example link: <%= link_to website_link, data: {controller: "external-link"} %></p>
+ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
+Warming up --------------------------------------
+            no slots    12.997k i/100ms
+               slots    10.891k i/100ms
+Calculating -------------------------------------
+            no slots    125.622k (± 5.4%) i/s    (7.96 μs/i) -      1.261M in  10.072521s
+               slots    108.468k (± 3.3%) i/s    (9.22 μs/i) -      1.089M in  10.053026s
 
-  <%= render lists, title: "Default title" %>
+Comparison:
+            no slots:   125621.9 i/s
+               slots:   108467.5 i/s - 1.16x  slower
 
-  <% if quotes.any? %>
-    <h3>Quotes</h3>
-    <% quotes.each do |quote| %>
-      <blockquote <%= quote.options.except(:citation) %>>
-        <%= quote %>
-        <%== "&mdash; #{tag.cite(quote.options.citation)}" if quote.options.citation.present? %>
-      </blockquote>
-    <% end %>
-  <% end %>
-<% end %>
-```
 
-```erb
-<!-- views/_list.html.erb -->
+✨🦄 NICE_PARTIALS 🦄✨
 
-<%# locals: (title:) -%>
-<%# slots: (items: nil) -%>
- 
-<h3><%= title %></h3>
+ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
+Warming up --------------------------------------
+            no slots    11.822k i/100ms
+               slots     4.204k i/100ms
+Calculating -------------------------------------
+            no slots    114.190k (± 4.7%) i/s    (8.76 μs/i) -      1.147M in  10.069870s
+               slots     41.138k (± 4.3%) i/s   (24.31 μs/i) -    411.992k in  10.039730s
 
-<% if items.any? %>
-  <%= tag.ul class: "list" do %>
-    <%= content_tag :li, items, class: "list-item" %>
-  <% end %>
-<% end %>
-```
+Comparison:
+            no slots:   114190.2 i/s
+               slots:    41137.9 i/s - 2.78x  slower
 
-```erb
-<!-- views/slotify.html.erb -->
 
-<%= render "example", id: "slotify-example" do |partial| %>
-  <% partial.with_subtitle do %>
-    This is the <%= tag.em "subtitle" %>
-  <% end %>
+✨🦄 VIEW_COMPONENT 🦄✨
 
-  <% partial.with_website_link "example.com", "https://example.com", target: "_blank", data: {controller: "preview-link"} %>
+ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
+Warming up --------------------------------------
+            no slots    20.329k i/100ms
+               slots     7.409k i/100ms
+Calculating -------------------------------------
+            no slots    196.288k (± 4.7%) i/s    (5.09 μs/i) -      1.972M in  10.073103s
+               slots     71.311k (± 5.0%) i/s   (14.02 μs/i) -    718.673k in  10.108426s
 
-  <% partial.with_list do |list| %>
-    <% list.with_item "first thing" %> 
-    <% list.with_item "second thing", class: "text-green-700" %>
-    <% list.with_item "third thing" %>
-  <% end %>
+Comparison:
+            no slots:   196287.6 i/s
+               slots:    71310.5 i/s - 2.75x  slower
 
-  <% partial.with_quote citation: "A. Person", class: "text-lg" do %>
-    <p>Lorem ipsum dolor sit amet consectetur adipisicing elit.</p>
-  <% end %>
 
-  <% partial.with_quote do %>
-    <p>Non quos explicabo eius hic quaerat laboriosam incidunt numquam.</p>
-  <% end %>
-<% end %>
-```
+✨🦄 SLOTIFY 🦄✨
 
+ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
+Warming up --------------------------------------
+            no slots    10.883k i/100ms
+               slots    77.000 i/100ms
+Calculating -------------------------------------
+            no slots    110.153k (± 4.8%) i/s    (9.08 μs/i) -      1.099M in  10.009002s
+               slots    789.118 (± 4.1%) i/s    (1.27 ms/i) -      7.931k in  10.071749s
 
+Comparison:
+            no slots:   110152.8 i/s
+               slots:      789.1 i/s - 139.59x  slower
+```

data/lib/slotify/concerns/slot_compatability.rb

@@ -0,0 +1,20 @@
+module Slotify
+  module SlotCompatability
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def make_compatible_with_slots(*method_names)
+        proxy = Module.new
+        method_names.each do |name|
+          proxy.define_method(name) do |*args, **kwargs, &block|
+            return super(*args, **kwargs, &block) if args.none?
+
+            results = MethodArgsResolver.call(args, kwargs, block) { super(*_1, **_2, &_3) }
+            results.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
+          end
+        end
+        prepend proxy
+      end
+    end
+  end
+end

data/lib/slotify/error.rb

@@ -2,7 +2,7 @@ module Slotify
   class UnknownSlotError < NameError
   end
 
-  class SlotsAccessError < RuntimeError
+  class SlotsDefinedError < RuntimeError
   end
 
   class UndefinedSlotError < StandardError
@@ -16,4 +16,7 @@ module Slotify
 
   class StrictSlotsError < ArgumentError
   end
+
+  class ReservedSlotNameError < ArgumentError
+  end
 end

data/lib/slotify/extensions/base.rb

@@ -1,25 +1,17 @@
 module Slotify
   module Extensions
     module Base
-      extend HelpersConcern
+      include SlotCompatability
 
-      attr_reader :partial
+      attr_accessor :partial
 
-      def render(target = {}, locals = {}, &block)
+      def render(options = {}, locals = {}, &block)
         @partial = Slotify::Partial.new(self)
         super
       ensure
         @partial = partial.outer_partial
       end
 
-      def _layout_for(*args, &block)
-        if block && args.first.is_a?(Symbol)
-          capture_with_outer_partial_access(*args, &block)
-        else
-          super
-        end
-      end
-
       def capture_with_outer_partial_access(*args, &block)
         inner_partial, @partial = partial, partial.outer_partial
         inner_partial.capture(*args, &block)

data/lib/slotify/extensions/partial_renderer.rb

@@ -4,10 +4,10 @@ module Slotify
       def render_partial_template(view, locals, template, layout, block)
         return super unless template.strict_slots?
 
-        partial = view.partial
+        view.partial.define_slots!(template.strict_slots_keys)
+
         view.capture_with_outer_partial_access(&block) if block
-        partial.with_strict_slots(template.strict_slots_keys)
-        locals = locals.merge(partial.slot_locals)
+        locals = locals.merge(view.partial.slot_locals)
 
         decorate_strict_slots_errors do
           super(view, locals, template, layout, block)

data/lib/slotify/extensions/template.rb

@@ -3,16 +3,17 @@ require "action_view/template/error"
 module Slotify
   module Extensions
     module Template
+      STRICT_SLOTS_NONE = Object.new
       STRICT_SLOTS_REGEX = /\#\s+slots:\s+\((.*)\)/
       STRICT_SLOTS_KEYS_REGEX = /(\w+):(?=(?:[^"\\]*(?:\\.|"(?:[^"\\]*\\.)*[^"\\]*"))*[^"]*$)/
 
       def initialize(...)
         super
-        @strict_slots = ActionView::Template::NONE
+        @strict_slots = STRICT_SLOTS_NONE
       end
 
       def strict_slots!
-        if @strict_slots == ActionView::Template::NONE
+        if @strict_slots == STRICT_SLOTS_NONE
           source.sub!(STRICT_SLOTS_REGEX, "")
           strict_slots = $1
           @strict_slots = if strict_slots.nil?
@@ -30,7 +31,7 @@ module Slotify
       end
 
       def strict_slots_keys
-        strict_slots!.scan(STRICT_SLOTS_KEYS_REGEX).map(&:first)
+        @strict_slots_keys ||= strict_slots!.scan(STRICT_SLOTS_KEYS_REGEX).map(&:first)
       end
 
       def strict_locals!
@@ -41,8 +42,9 @@ module Slotify
 
       def locals_code
         return super unless strict_slots?
+
         strict_slots_keys.each_with_object(+super) do |key, code|
-          code << "#{key} = partial.content_for(:#{key}, binding.local_variable_get(:#{key}));"
+          code << "partial.set_slot_default(:#{key}, binding.local_variable_get(:#{key})); #{key} = partial.public_send(:#{key});"
         end
       end
     end

data/lib/slotify/partial.rb

@@ -2,32 +2,31 @@ module Slotify
   class Partial
     include InflectionHelper
 
+    RESERVED_SLOT_NAMES = [
+      :content, :slot, :value, :content_for,
+      :capture, :yield, :partial
+    ]
+
     attr_reader :outer_partial
 
     def initialize(view_context)
       @view_context = view_context
       @outer_partial = view_context.partial
-      @values = []
-      @strict_slots = nil
+      @values = ValueStore.new(@view_context)
+      @defined_slots = nil
     end
 
-    def content_for(slot_name, fallback_value = nil)
-      raise SlotsAccessError, "slot values cannot be accessed from outside the partial" unless slots_defined?
-      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot_defined?(slot_name)
-
-      values = slot_values(slot_name)
-      if values.none? && !fallback_value.nil?
-        values = add_values(slot_name, Array(fallback_value))
-      end
+    def content_for(slot_name)
+      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot?(slot_name)
 
-      singular?(slot_name) ? values.first : ValueCollection.new(values)
+      slot_values = values.for(slot_name)
+      singular?(slot_name) ? slot_values.first : ValueCollection.new(slot_values)
     end
 
     def content_for?(slot_name)
-      raise SlotsAccessError, "slot values cannot be accessed from outside the partial" unless slots_defined?
-      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot_defined?(slot_name)
+      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot?(slot_name)
 
-      slot_values(slot_name).any?
+      values.for(slot_name).any?
     end
 
     def capture(*args, &block)
@@ -35,19 +34,30 @@ module Slotify
     end
 
     def yield(*args)
-      if args.empty?
-        @captured_buffer
-      else
-        content_for(args.first)
+      args.empty? ? @captured_buffer : content_for(args.first)
+    end
+
+    def content
+      self.yield
+    end
+
+    def set_slot_default(slot_name, default_value)
+      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot?(slot_name)
+
+      if values.for(slot_name).none? && !default_value.nil?
+        values.add(slot_name, Array.wrap(default_value))
       end
     end
 
     def slot_locals
-      pairs = @strict_slots.map do |slot_name|
-        values = slot_values(slot_name)
-        values = singular?(slot_name) ? values&.first : values
-        [slot_name, values]
+      validate_slots!
+
+      pairs = @defined_slots.map do |slot_name|
+        slot_values = values.for(slot_name)
+        slot_values = singular?(slot_name) ? slot_values&.first : slot_values
+        [slot_name, slot_values]
       end
+
       pairs.filter do |key, value|
         # keep empty strings as local value but filter out empty arrays
         # and objects so they don't override any default values set via strict slots.
@@ -55,69 +65,50 @@ module Slotify
       end.to_h
     end
 
-    def with_strict_slots(strict_slot_names)
-      @strict_slots = strict_slot_names.map(&:to_sym)
-      validate_slots!
+    def define_slots!(slot_names)
+      raise SlotsDefinedError, "Slots cannot be redefined" unless @defined_slots.nil?
+
+      @defined_slots = slot_names.map(&:to_sym).each do |slot_name|
+        if RESERVED_SLOT_NAMES.include?(singularize(slot_name))
+          raise ReservedSlotNameError, ":#{slot_name} is a reserved word and cannot be used as a slot name"
+        end
+      end
     end
 
     def respond_to_missing?(name, include_private = false)
-      name.start_with?("with_")
+      name.start_with?("with_") || slot?(name)
     end
 
     def method_missing(name, *args, **options, &block)
       if name.start_with?("with_")
-        slot_name = name.to_s.delete_prefix("with_")
-        if singular?(slot_name)
-          add_value(slot_name, args, options, block)
-        else
-          collection = args.first
-          add_values(slot_name, collection, options, block)
-        end
+        values.add(name.to_s.delete_prefix("with_"), args, options, block)
+      elsif slot?(name)
+        content_for(name)
+      else
+        super
       end
     end
 
     private
 
-    def slots_defined?
-      !@strict_slots.nil?
-    end
-
-    def slot_defined?(slot_name)
-      slot_name && slots_defined? && @strict_slots.include?(slot_name.to_sym)
-    end
-
-    def slot_values(slot_name)
-      @values.filter { _1.slot_name == singularize(slot_name) }
-    end
+    attr_reader :values
 
-    def add_values(slot_name, collection, options = {}, block = nil)
-      collection.map { add_value(slot_name, _1, options, block) }
-    rescue NoMethodError
-      raise SlotArgumentError, "expected array to be passed to slot :#{slot_name} (received #{collection.class.name})"
-    end
-
-    def add_value(slot_name, args = [], options = {}, block = nil)
-      MethodArgsResolver.call(args, options, block) do
-        @values << Value.new(@view_context, singularize(slot_name), _1, _2, _3)
-      end
-
-      @values.last
+    def slot?(slot_name)
+      slot_name && @defined_slots.include?(slot_name.to_sym)
     end
 
     def validate_slots!
-      return if @strict_slots.nil?
-
-      singular_slots = @strict_slots.map { singularize(_1) }
-      slots_called = @values.map(&:slot_name).uniq
-      undefined_slots = slots_called - singular_slots
+      return if @defined_slots.nil?
 
+      undefined_slots = values.slot_names - @defined_slots.map { singularize(_1) }
       if undefined_slots.any?
-        raise UndefinedSlotError, "missing slot #{"definition".pluralize(undefined_slots.size)} for `#{undefined_slots.map { ":#{_1}(s)" }.join(", ")}`"
+        raise UndefinedSlotError,
+          "missing slot #{"definition".pluralize(undefined_slots.size)} for `#{undefined_slots.map { ":#{_1}(s)" }.join(", ")}`"
       end
 
-      @strict_slots.filter { singular?(_1) }.each do |slot_name|
-        values = slot_values(slot_name)
-        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{values.size} times (expected 1)" if values.many?
+      @defined_slots.filter { singular?(_1) }.each do |slot_name|
+        slot_values = values.for(slot_name)
+        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{slot_values.size} times (expected 1)" if slot_values.many?
       end
     end
   end

data/lib/slotify/value.rb

@@ -4,11 +4,11 @@ module Slotify
 
     attr_reader :slot_name, :args, :block
 
-    delegate :presence, to: :@content
+    delegate :presence, :to_s, :to_str, to: :content
 
-    def initialize(view_context, slot_name, args = [], options = {}, block = nil, partial_path: nil)
+    def initialize(view_context, args = [], options = {}, block = nil, slot_name: nil, partial_path: nil)
       @view_context = view_context
-      @slot_name = slot_name.to_sym
+      @slot_name = slot_name&.to_sym
       @args = args
       @options = options.to_h
       @block = block
@@ -20,21 +20,16 @@ module Slotify
     end
 
     def content
-      body = if @block && @block.arity == 0
-        @view_context.capture(&@block)
+      if @block && @block.arity == 0
+        body = @view_context.capture(&@block)
+        ActiveSupport::SafeBuffer.new(body.presence || "")
+      elsif args.first.is_a?(String)
+        ActiveSupport::SafeBuffer.new(args.first)
       else
-        begin
-          args.first.to_str
-        rescue NoMethodError
-          ""
-        end
+        args.first
       end
-      ActiveSupport::SafeBuffer.new(body.presence || "")
     end
 
-    alias_method :to_s, :content
-    alias_method :to_str, :content
-
     def present?
       @args.present? || @options.present? || @block
     end
@@ -52,24 +47,30 @@ module Slotify
     alias_method :to_hash, :to_h
 
     def with_partial_path(partial_path)
-      Value.new(@view_context, @slot_name, @args, options, @block, partial_path:)
+      Value.new(@view_context, @args, options, @block, slot_name: @slot_name, partial_path:)
     end
 
     def with_default_options(default_options)
       options = TagOptionsMerger.call(default_options, @options)
-      Value.new(@view_context, @slot_name, @args, options, @block)
+      Value.new(@view_context, @args, options, @block, slot_name: @slot_name)
     end
 
     def respond_to_missing?(name, include_private = false)
       name.start_with?("to_") || super
     end
 
-    def method_missing(name, *args, **options)
-      if name.start_with?("to_") && args.none?
-        @args.first.public_send(name)
+    def method_missing(name, ...)
+      if name.start_with?("to_")
+        @args.first.public_send(name, ...)
+      else
+        super
       end
     end
 
+    def [](key)
+      key.is_a?(Integer) ? @args[key] : super
+    end
+
     def render_in(view_context, &block)
       view_context.render partial_path, **@options.to_h, &@block || block
     end

data/lib/slotify/value_store.rb

@@ -0,0 +1,28 @@
+module Slotify
+  class ValueStore
+    include InflectionHelper
+
+    def initialize(view_context)
+      @view_context = view_context
+      @values = []
+    end
+
+    def for(slot_name)
+      @values.select { _1.slot_name == singularize(slot_name) }
+    end
+
+    def add(slot_name, args = [], options = {}, block = nil)
+      if plural?(slot_name)
+        Array.wrap(args.first).map { add(singularize(slot_name), _1, options, block) }
+      else
+        MethodArgsResolver.call(args, options, block) do
+          @values << Value.new(@view_context, _1, _2, _3, slot_name: singularize(slot_name))
+        end
+      end
+    end
+
+    def slot_names
+      @values.map(&:slot_name).uniq
+    end
+  end
+end

data/lib/slotify/version.rb

@@ -1,3 +1,3 @@
 module Slotify
-  VERSION = "0.0.1"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slotify
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - Mark Perkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-06 00:00:00.000000000 Z
+date: 2025-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -46,8 +46,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/slotify.rb
-- lib/slotify/concerns/helpers_concern.rb
 - lib/slotify/concerns/inflection_helper.rb
+- lib/slotify/concerns/slot_compatability.rb
 - lib/slotify/error.rb
 - lib/slotify/extensions/base.rb
 - lib/slotify/extensions/partial_renderer.rb
@@ -58,6 +58,7 @@ files:
 - lib/slotify/value.rb
 - lib/slotify/value_collection.rb
 - lib/slotify/value_options.rb
+- lib/slotify/value_store.rb
 - lib/slotify/version.rb
 homepage:
 licenses:
@@ -78,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Superpowered slots for your Rails partials.

data/lib/slotify/concerns/helpers_concern.rb

@@ -1,16 +0,0 @@
-module Slotify
-  module HelpersConcern
-    def make_compatible_with_slots(*method_names)
-      proxy = Module.new
-      method_names.each do |name|
-        proxy.define_method(name) do |*args, **kwargs, &block|
-          return super(*args, **kwargs, &block) if args.none?
-
-          results = MethodArgsResolver.call(args, kwargs, block) { super(*_1, **_2, &_3) }
-          results.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
-        end
-      end
-      prepend proxy
-    end
-  end
-end