slotify 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 905eaee14b280c6b59fed9887ab8ecf8e1796ca341296debf5c532bbb83ccd5f
-  data.tar.gz: a260b0e8f3eda211a58f48ac5389ebebc84935888fcf6355a00145338005f33f
+  metadata.gz: 9401d13b9a845572abccc1cd38362bb6facfb5394568a74345d856abc6db80ea
+  data.tar.gz: bd8c9df4efe6ee8d40d7967f06326b9950d160c824828c11537f5c44f63f200c
 SHA512:
-  metadata.gz: 5a4b87a2792a032cde484a793dea94025f091a1bfa2464938437dda769ada354b788193aa896831da5d10e1506d8ada25e6a41287cfd9ff539eda3447c88a7f0
-  data.tar.gz: 714fcfd6cfa44f24c7c562f72edaf5833e8b25048d5de639b753f9359c97c7fa0586abb478200ea1a4c5700dbf8774b7e7623a25697084cf8674dc487b9a23e6
+  metadata.gz: 1af7661c421919e5bc90069a75781075e27b9f97d1d767148f5ece3abe773dc1b206ea59435e511c7e1b1805a34124b19b4e1d8354fc7cf70e27dfbcd4e7445a
+  data.tar.gz: 2c3f889e7f55d65af6be315c9b013a21ab63b8cee3c9304cf3ebd947b3324c899c0830e5ea420d1aac7bda0d54603fe69d97eb87fdc765c1a8c0f8f70ec9af69

data/README.md

@@ -1,81 +1,261 @@
-<img src=".github/assets/slotify_wordmark.svg" width="140">
-  
+<img src=".github/assets/slotify_wordmark.svg" width="200">
+
+
+
+### Superpowered slots for ActionView partials
 
+---
 
-#### _A superpowered slot system for Rails partials._
+## Overview 
 
-----------
+Slotify adds an unobtrusive (but powerful!) **content slot API** to ActionView partials.
 
-## Overview
+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.
 
-Slotify adds a lightweight (but powerful!) slot system for providing content to partials when rendering them.
+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/).
 
-Slots are defined using a `strict locals`-style magic comment at the top of the partial.
-Slot content is accessed via 'regular' local variables within the template.
+### 
+
+## 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)).
 
 ```erb
-<!-- views/_my_partial_.html.erb -->
+<%# slots: (slot_name: "default value", optional_slot_name: nil, required_slot_name:) -%>
+```
 
-<%# slots: (title: "Example title", items: nil, link:) -%>
+Slot content is accessed via **standard local variables** within the partial. So a simple, slot-enabled `article` partial template might look something like this:
 
-<div>
-  <h1><%= title %></h1>
+```erb
+<!-- _article.html.erb -->
+
+<%# slots: (heading: "Default title", body: nil) -%>
 
-  <% if items.any? %>
-    <ul>
-      <%= items.each do |item| %>
-        <li <%= item.options %>>
-          <%= item %>
-        </li>
-      <% end%>
-    </ul>
+<article>
+  <h1><%= heading %></h1>
+  <% if body.present? %>
+    <div>
+      <%= body %>
+    </div>
   <% end %>
+</article>
+```
 
-  <p>
-    Example link: <%= partial.link_to link, class: "example-link" %>
-  </p>
-</div>
+> [!NOTE]
+> _The above should feel familiar to anyone who has partials (and strict locals) in the past. This is just regular partial syntax but with `slots` defined instead of `locals` (don't worry - you can still define locals too!)._
+
+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:
+
+```erb
+<%= render "article" do |partial| %>
+  <% partial.with_heading "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>
+  <% end %>
+<% end %>
+```
+
+> [!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)).
+
+## Usage
+
+<a name="defining-slots" id="defining-slots"></a>
+### Defining slots
+
+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) -%>
+```
+
+#### Required slots
+
+Required slots are defined without a default value.
+If no content is provided for a required slot then a `StrictSlotsError` exception will be raised.
+
+```erb
+<!-- _required.html.erb -->
+
+<%# slots: (title:) -%>
+<h1><%= title %></h1>
+```
+
+```erb
+<%= render "required" do |partial| %>  
+  <!-- ❌ raises an error, no content set for the `title` slot -->
+<% end %>
+```
+
+#### Optional slots
+
+If a default value is set then the slot becomes _optional_. If no content is provided when rendering the partial then
+the default value will be used instead.
+
+```erb
+<%# slots: (title: "Default title", author: nil) -%>
+```
+
+### Using alongside strict locals
+
+Strict locals can be defined in 'slotified' partial templates in the same way as usual,
+either above or below the `slots` definition.
+
+```erb
+<!-- _article.html.erb -->
+
+<%# locals: (title:) -%>
+<%# slots: (summary: "No summary available") -%>
+
+<article>
+  <h1><%= title %></h1>
+  <div><%= summary %></div>
+</article>
+```
+
+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>
+  <% end %>
+<% end %>
 ```
 
-Content can then be provided to slots when rendering the partial:
+### Slot content and options
+
+Content is passed into slots using dynamically generated `partial#with_<slot_name>` 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:
 
 ```erb
-<%= render "my_partial", do |partial| %>
-  <%= partial.with_title do %>
-    This is a title
+<%= render "example" do |partial| %>
+  <% partial.with_title "Title passed as argument" %>
+  <% partial.with_title do %>
+    Title passed as block content
   <% end %>
+<% end %>
+```
+
+### Slot types
+
+There are two types of slots.
+
+* **Single-value** slots can only be called **once** and return **a single value**.
+* **Multiple-value** slots can be called **many times** and return **an array of values**.
+
+#### Single-value slots
+
+Single-value slots are defined using a **singlular** slot name:
+
+```erb
+<%# slots: (item: nil) -%>
+```
 
-  <%= partial.with_item "Item 1" %>
-  <%= partial.with_item "Item 2", class: "text-green-700" %>
+Single-value slots can be called once (at most)
+and their corresponding template variable represents a single value:
 
-  <% partial.with_link "example.com", "https://example.com", target: "_blank" %>
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
 <% end %>
 ```
 
-Slots defined with singular names can only be called with content once whereas slots defined with plural names can be called multiple times.
+```erb
+<%# slots: (item: nil) -%>
+<div>
+  <%= item %> <!-- "Item one" -->
+</div>
+```
 
-### Requirements
+> [!WARNING]
+> Calling a single-value slot more than once when rendering a partial will raise an error:
+> 
+> ```erb
+> <%= render "example" do |partial| %>
+>   <% partial.with_item "Item one" %>
+>   <% partial.with_item "Item two" %> # ❌ raises an error!
+> <% end %>
+> ```
 
-* `Rails 8.0+`
-* `Ruby 3.1+`
+#### Multiple-value slots
 
-## Usage
+Multiple-value slots are defined using a **plural** slot name:
 
- 🚧 Work in progress! 🚧
+```erb
+<%# slots: (items: nil) -%>
+```
 
-### Defining slots
+Multiple-value slots can be called as many times as needed
+and their corresponding template variable represents an array of values:
 
-Slots are defined using a `strict locals`-style magic comment at the top of the partial template.
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+  <% partial.with_item "Item two" %>
+  <% partial.with_item "Item three" %>
+<% end %>
+```
 
 ```erb
-<%# slots: (title: "Example title", lists: nil, quotes: nil, website_link:) -%>
+<%# slots: (items: nil) -%>
+
+<%= items %> <!-- ["Item one", "Item two", "Item three"] -->
+
+<ul>
+  <% items.each do |item| %>
+    <li>
+      <% item %>
+    </li>
+  <% end %>
+</ul>
 ```
 
-* Singular slots can only accept one entry, plural slots can accept many.
-* Slots can be required (no default value) or optional.
-* Optional slots can additionaly specify default content as needed.
+### Passing slot content to helpers
 
-### A more complete example
+> _Docs coming soon..._ 
+
+### Rendering slots
+
+> _Docs coming soon..._ 
+
+### Slot value objects
+
+> _Docs coming soon..._ 
+
+## Installation
+
+Add the following to your Rails app Gemfile:
+
+```rb
+gem "slotify"
+```
+
+And then run `bundle install`. You are good to go!
+
+## Requirements
+
+* `Rails 7.1+`
+* `Ruby 3.1+`
+
+## Credits
+
+Slotify was inspired by the excellent [nice_partials gem](https://github.com/bullet-train-co/nice_partials) as well as ViewComponent's [slots implementation](https://viewcomponent.org/guide/slots.html).
+
+`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)!
+
+--- 
+
+<a name="full-example" id="full-example"></a>
+
+## A more full-featured example
 
 ```erb
 <!-- views/_example.html.erb -->
@@ -88,7 +268,7 @@ Slots are defined using a `strict locals`-style magic comment at the top of the
     <%= title %>
   </h1>
   
-  <p>Example link: <%= partial.link_to website_link, data: {controller: "external-link"} %></p>
+  <p>Example link: <%= link_to website_link, data: {controller: "external-link"} %></p>
 
   <%= render lists, title: "Default title" %>
 
@@ -114,7 +294,7 @@ Slots are defined using a `strict locals`-style magic comment at the top of the
 
 <% if items.any? %>
   <%= tag.ul class: "list" do %>
-    <%= partial.li items, class: "list-item" %>
+    <%= content_tag :li, items, class: "list-item" %>
   <% end %>
 <% end %>
 ```
@@ -145,6 +325,4 @@ Slots are defined using a `strict locals`-style magic comment at the top of the
 <% end %>
 ```
 
-## Credits
 
-Slotify was heavily influenced by (and borrows some code from) the excellent [nice_partials gem](https://github.com/bullet-train-co/nice_partials). It provides similar functionality to Slotify so if you are not convinced by what you see here then go check it out!

data/lib/slotify/concerns/helpers_concern.rb

@@ -0,0 +1,16 @@
+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

data/lib/slotify/concerns/inflection_helper.rb

@@ -0,0 +1,18 @@
+module Slotify
+  module InflectionHelper
+    extend ActiveSupport::Concern
+
+    def singular?(str)
+      str = str.to_s
+      str.singularize == str && str.pluralize != str
+    end
+
+    def singularize(sym)
+      sym.to_s.singularize.to_sym
+    end
+
+    def plural?(str)
+      !singular?(str)
+    end
+  end
+end

data/lib/slotify/error.rb

@@ -0,0 +1,19 @@
+module Slotify
+  class UnknownSlotError < NameError
+  end
+
+  class SlotsAccessError < RuntimeError
+  end
+
+  class UndefinedSlotError < StandardError
+  end
+
+  class MultipleSlotEntriesError < ArgumentError
+  end
+
+  class SlotArgumentError < ArgumentError
+  end
+
+  class StrictSlotsError < ArgumentError
+  end
+end

data/lib/slotify/extensions/base.rb

@@ -0,0 +1,34 @@
+module Slotify
+  module Extensions
+    module Base
+      extend HelpersConcern
+
+      attr_reader :partial
+
+      def render(target = {}, 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)
+      ensure
+        @partial = inner_partial
+      end
+
+      make_compatible_with_slots :url_for, :link_to, :button_to, :link_to_unless_current,
+        :link_to_unless, :link_to_if, :mail_to, :sms_to, :phone_to, :tag, :content_tag
+    end
+  end
+end

data/lib/slotify/extensions/partial_renderer.rb

@@ -0,0 +1,39 @@
+module Slotify
+  module Extensions
+    module PartialRenderer
+      def render_partial_template(view, locals, template, layout, block)
+        return super unless template.strict_slots?
+
+        partial = view.partial
+        view.capture_with_outer_partial_access(&block) if block
+        partial.with_strict_slots(template.strict_slots_keys)
+        locals = locals.merge(partial.slot_locals)
+
+        decorate_strict_slots_errors do
+          super(view, locals, template, layout, block)
+        end
+      end
+
+      def decorate_strict_slots_errors(&block)
+        yield
+      rescue ActionView::Template::Error => error
+        if missing_strict_locals_error?(error)
+          local_names = error.cause.message.scan(/\s:(\w+)/).flatten
+          if local_names.any?
+            slot_names = local_names.intersection(error.template.strict_slots_keys).map { ":#{_1}" }
+            if slot_names.any?
+              message = "missing #{"slot".pluralize(slot_names.size)}: #{slot_names.join(", ")} for #{error.template.short_identifier}"
+              raise Slotify::StrictSlotsError, message
+            end
+          end
+        end
+        raise error
+      end
+
+      def missing_strict_locals_error?(error)
+        error.template && (defined?(ActionView::StrictLocalsError) && error.cause.is_a?(ActionView::StrictLocalsError)) ||
+          (error.cause.is_a?(ArgumentError) && error.cause.message.match(/missing local/))
+      end
+    end
+  end
+end

data/lib/slotify/extensions/template.rb

@@ -0,0 +1,50 @@
+require "action_view/template/error"
+
+module Slotify
+  module Extensions
+    module Template
+      STRICT_SLOTS_REGEX = /\#\s+slots:\s+\((.*)\)/
+      STRICT_SLOTS_KEYS_REGEX = /(\w+):(?=(?:[^"\\]*(?:\\.|"(?:[^"\\]*\\.)*[^"\\]*"))*[^"]*$)/
+
+      def initialize(...)
+        super
+        @strict_slots = ActionView::Template::NONE
+      end
+
+      def strict_slots!
+        if @strict_slots == ActionView::Template::NONE
+          source.sub!(STRICT_SLOTS_REGEX, "")
+          strict_slots = $1
+          @strict_slots = if strict_slots.nil?
+            ""
+          else
+            strict_slots.sub("**", "").strip.delete_suffix(",")
+          end
+        end
+
+        @strict_slots
+      end
+
+      def strict_slots?
+        strict_slots!.present?
+      end
+
+      def strict_slots_keys
+        strict_slots!.scan(STRICT_SLOTS_KEYS_REGEX).map(&:first)
+      end
+
+      def strict_locals!
+        return super unless strict_slots?
+
+        [strict_slots!, super].compact.join(", ")
+      end
+
+      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}));"
+        end
+      end
+    end
+  end
+end

data/lib/slotify/partial.rb

@@ -0,0 +1,124 @@
+module Slotify
+  class Partial
+    include InflectionHelper
+
+    attr_reader :outer_partial
+
+    def initialize(view_context)
+      @view_context = view_context
+      @outer_partial = view_context.partial
+      @values = []
+      @strict_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
+
+      singular?(slot_name) ? values.first : ValueCollection.new(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)
+
+      slot_values(slot_name).any?
+    end
+
+    def capture(*args, &block)
+      @captured_buffer = @view_context.capture(*args, self, &block)
+    end
+
+    def yield(*args)
+      if args.empty?
+        @captured_buffer
+      else
+        content_for(args.first)
+      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]
+      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.
+        value.is_a?(String) || value&.present?
+      end.to_h
+    end
+
+    def with_strict_slots(strict_slot_names)
+      @strict_slots = strict_slot_names.map(&:to_sym)
+      validate_slots!
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.start_with?("with_")
+    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
+      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
+
+    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
+    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
+
+      if undefined_slots.any?
+        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?
+      end
+    end
+  end
+end

data/lib/slotify/services/method_args_resolver.rb

@@ -0,0 +1,26 @@
+module Slotify
+  module MethodArgsResolver
+    class << self
+      def call(args = [], options = {}, block = nil)
+        args = args.is_a?(Array) ? args.clone : [args]
+        value_index = args.index { _1.is_a?(ValueCollection) || _1.is_a?(Value) }
+        if value_index.nil?
+          [yield(args, options, block)]
+        else
+          target = args[value_index]
+          values = target.is_a?(ValueCollection) ? target : [target]
+          values.map do |value|
+            cloned_args = args.clone
+            cloned_args[value_index, 1] = value.args.clone
+
+            yield(
+              cloned_args,
+              TagOptionsMerger.call(options, value.options),
+              value.block || block
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slotify/services/tag_options_merger.rb

@@ -0,0 +1,54 @@
+module Slotify
+  module TagOptionsMerger
+    class << self
+      include ::ActionView::Helpers::TagHelper
+
+      def call(original, target)
+        original = original.to_h.deep_symbolize_keys
+        target = target.to_h.deep_symbolize_keys
+
+        target.each do |key, value|
+          original[key] = case key
+          when :data
+            merge_data_options(original[key], value)
+          when :class
+            merge_class_options(original[key], value)
+          else
+            value
+          end
+        end
+
+        original
+      end
+
+      private
+
+      def merge_data_options(original_data, target_data)
+        original_data = original_data.dup
+
+        target_data.each do |key, value|
+          values = [original_data[key], value]
+          original_data[key] = if key.in?([:controller, :action]) && all_kind_of?(String, values)
+            merge_strings(values)
+          else
+            value
+          end
+        end
+
+        original_data
+      end
+
+      def merge_class_options(original_classes, target_classes)
+        class_names(original_classes, target_classes)
+      end
+
+      def merge_strings(*args)
+        args.map(&:presence).compact.join(" ")
+      end
+
+      def all_kind_of?(kind, values)
+        values.none? { !_1.is_a?(kind) }
+      end
+    end
+  end
+end

data/lib/slotify/value.rb

@@ -0,0 +1,83 @@
+module Slotify
+  class Value
+    include InflectionHelper
+
+    attr_reader :slot_name, :args, :block
+
+    delegate :presence, to: :@content
+
+    def initialize(view_context, slot_name, args = [], options = {}, block = nil, partial_path: nil)
+      @view_context = view_context
+      @slot_name = slot_name.to_sym
+      @args = args
+      @options = options.to_h
+      @block = block
+      @partial_path = partial_path
+    end
+
+    def options
+      ValueOptions.new(@view_context, @options)
+    end
+
+    def content
+      body = if @block && @block.arity == 0
+        @view_context.capture(&@block)
+      else
+        begin
+          args.first.to_str
+        rescue NoMethodError
+          ""
+        end
+      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
+
+    def empty?
+      @args.empty? || @options.empty? || !@block
+    end
+
+    alias_method :blank?, :empty?
+
+    def to_h
+      @options
+    end
+
+    alias_method :to_hash, :to_h
+
+    def with_partial_path(partial_path)
+      Value.new(@view_context, @slot_name, @args, options, @block, partial_path:)
+    end
+
+    def with_default_options(default_options)
+      options = TagOptionsMerger.call(default_options, @options)
+      Value.new(@view_context, @slot_name, @args, options, @block)
+    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)
+      end
+    end
+
+    def render_in(view_context, &block)
+      view_context.render partial_path, **@options.to_h, &@block || block
+    end
+
+    private
+
+    def partial_path
+      @partial_path || @slot_name.to_s
+    end
+  end
+end

data/lib/slotify/value_collection.rb

@@ -0,0 +1,31 @@
+module Slotify
+  class ValueCollection
+    include Enumerable
+
+    delegate_missing_to :@values
+
+    def initialize(values = [])
+      @values = values.is_a?(Value) ? [values] : values
+    end
+
+    def with_default_options(...)
+      ValueCollection.new(map { _1.with_default_options(...) })
+    end
+
+    def with_partial_path(...)
+      ValueCollection.new(map { _1.with_partial_path(...) })
+    end
+
+    def to_s
+      @values.reduce(ActiveSupport::SafeBuffer.new) do |buffer, value|
+        buffer << value.to_s
+      end
+    end
+
+    def render_in(view_context, &block)
+      @values.reduce(ActiveSupport::SafeBuffer.new) do |buffer, value|
+        buffer << value.render_in(view_context, &block)
+      end
+    end
+  end
+end

data/lib/slotify/value_options.rb

@@ -0,0 +1,20 @@
+module Slotify
+  class ValueOptions < ActiveSupport::OrderedOptions
+    def initialize(view_context, options = {})
+      @view_context = view_context
+      merge!(options)
+    end
+
+    def except(...)
+      ValueOptions.new(@view_context, to_h.except(...))
+    end
+
+    def slice(...)
+      ValueOptions.new(@view_context, to_h.slice(...))
+    end
+
+    def to_s
+      @view_context.tag.attributes(self)
+    end
+  end
+end

data/lib/slotify/version.rb

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

data/lib/slotify.rb

@@ -1,3 +1,21 @@
+require "zeitwerk"
+require "action_view"
 require_relative "slotify/version"
+require_relative "slotify/error"
+
+loader = Zeitwerk::Loader.for_gem
+loader.tag = "slotify"
+loader.push_dir("#{__dir__}/slotify", namespace: Slotify)
+loader.collapse("#{__dir__}/slotify/concerns")
+loader.collapse("#{__dir__}/slotify/services")
+loader.enable_reloading if ENV["RAILS_ENV"] == "development"
+loader.setup
+
+ActiveSupport.on_load :action_view do
+  prepend Slotify::Extensions::Base
+  ActionView::Template.prepend Slotify::Extensions::Template
+  ActionView::PartialRenderer.prepend Slotify::Extensions::PartialRenderer
+end
+
 module Slotify
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: slotify
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Mark Perkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-31 00:00:00.000000000 Z
-dependencies: []
+date: 2025-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 executables: []
@@ -18,6 +46,18 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/slotify.rb
+- lib/slotify/concerns/helpers_concern.rb
+- lib/slotify/concerns/inflection_helper.rb
+- lib/slotify/error.rb
+- lib/slotify/extensions/base.rb
+- lib/slotify/extensions/partial_renderer.rb
+- lib/slotify/extensions/template.rb
+- lib/slotify/partial.rb
+- lib/slotify/services/method_args_resolver.rb
+- lib/slotify/services/tag_options_merger.rb
+- lib/slotify/value.rb
+- lib/slotify/value_collection.rb
+- lib/slotify/value_options.rb
 - lib/slotify/version.rb
 homepage:
 licenses:
@@ -38,8 +78,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
-summary: A superpowered slot system for Rails partials.
+summary: Superpowered slots for your Rails partials.
 test_files: []