slotify 0.0.1.alpha.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b774ed1d3d704f77cbeebc55d117488eb70f52c1a00527dda727d6cb9100d72
-  data.tar.gz: b8c6ce6b033715c768315671e6d3547925943825a100f5ea67e11d7df7b81ba6
+  metadata.gz: 9401d13b9a845572abccc1cd38362bb6facfb5394568a74345d856abc6db80ea
+  data.tar.gz: bd8c9df4efe6ee8d40d7967f06326b9950d160c824828c11537f5c44f63f200c
 SHA512:
-  metadata.gz: ad4a579d74c471684a40b0d60cd8362325cb529d13a362c73d23f5aa67f7383d8d4c9853ebe3e9e4120a31126c4a0069688c924a38ceb8ae0d857e0ba3935b59
-  data.tar.gz: c64f9c44d9880d0488acac9bcc0a4882780b1517024ac86c3b73177f287817bf70ea52d036b74516c0e3f7a4681453acdfccda46b1d9b98ca80f011a09857ebf
+  metadata.gz: 1af7661c421919e5bc90069a75781075e27b9f97d1d767148f5ece3abe773dc1b206ea59435e511c7e1b1805a34124b19b4e1d8354fc7cf70e27dfbcd4e7445a
+  data.tar.gz: 2c3f889e7f55d65af6be315c9b013a21ab63b8cee3c9304cf3ebd947b3324c899c0830e5ea420d1aac7bda0d54603fe69d97eb87fdc765c1a8c0f8f70ec9af69

data/README.md

@@ -1,28 +1,30 @@
 <img src=".github/assets/slotify_wordmark.svg" width="200">
 
-#### 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 tool for building components** in a Rails app if you want to stay close to _The Rails Way™️_ or just want to avoid the additional overhead and learning curve of libraries like [ViewComponent](https://viewcomponent.org/) or [Phlex](https://www.phlex.fun/).
+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/).
 
 ### 
 
 ## 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:) -%>
 ```
 
-Slot content is accessed via standard local variables within the partial. So a simple slot-enabled `article` partial template might look something like this:
+Slot content is accessed via **standard local variables** within the partial. So a simple, slot-enabled `article` partial template might look something like this:
 
 ```erb
 <!-- _article.html.erb -->
@@ -40,15 +42,13 @@ Slot content is accessed via standard local variables within the partial. So a s
 ```
 
 > [!NOTE]
-> _The above code should feel familiar if you have used partials 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!)._
+> _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.
+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
-<!-- index.html.erb -->
-
 <%= render "article" do |partial| %>
   <% partial.with_heading "This is a title" %>
   <% partial.with_body do %>
@@ -61,50 +61,172 @@ 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)._
 
-The example above just scratches the surface of what Slotify slots can do.
+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)).
 
-You can [jump to a more full-featured example here](#full-example) or read on to learn more...
+## Usage
 
-## Single vs multiple value slots
+<a name="defining-slots" id="defining-slots"></a>
+### Defining slots
 
-> _Docs coming soon..._ 
+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:
 
-## Slot arguments and options
+```erb
+<%# slots: (title:, summary: "No summary available", author: nil) -%>
+```
 
-> _Docs coming soon..._ 
+#### Required slots
 
-## Using helpers with 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.
 
-> _Docs coming soon..._ 
+```erb
+<!-- _required.html.erb -->
 
-## Rendering slot contents
+<%# slots: (title:) -%>
+<h1><%= title %></h1>
+```
 
-> _Docs coming soon..._ 
+```erb
+<%= render "required" do |partial| %>  
+  <!-- ❌ raises an error, no content set for the `title` slot -->
+<% end %>
+```
 
-<a name="defining-slots" id="defining-slots"></a>
-## Defining slots
+#### Optional 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.
+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.
 
-> _Docs coming soon..._ 
+```erb
+<%# slots: (title: "Default title", author: nil) -%>
+```
 
-### Required slots
+### Using alongside strict locals
 
-> _Docs coming soon..._ 
+Strict locals can be defined in 'slotified' partial templates in the same way as usual,
+either above or below the `slots` definition.
 
-### Optional slots
+```erb
+<!-- _article.html.erb -->
 
-> _Docs coming soon..._ 
+<%# 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 %>
+```
+
+### Slot content and options
 
-### Setting default values
+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 "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) -%>
+```
+
+Single-value slots can be called once (at most)
+and their corresponding template variable represents a single value:
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+<% end %>
+```
+
+```erb
+<%# slots: (item: nil) -%>
+<div>
+  <%= item %> <!-- "Item one" -->
+</div>
+```
+
+> [!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 %>
+> ```
+
+#### Multiple-value slots
+
+Multiple-value slots are defined using a **plural** slot name:
+
+```erb
+<%# slots: (items: nil) -%>
+```
+
+Multiple-value slots can be called as many times as needed
+and their corresponding template variable represents an array of values:
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+  <% partial.with_item "Item two" %>
+  <% partial.with_item "Item three" %>
+<% end %>
+```
+
+```erb
+<%# slots: (items: nil) -%>
+
+<%= items %> <!-- ["Item one", "Item two", "Item three"] -->
+
+<ul>
+  <% items.each do |item| %>
+    <li>
+      <% item %>
+    </li>
+  <% end %>
+</ul>
+```
+
+### Passing slot content to helpers
 
 > _Docs coming soon..._ 
 
-### Using alongside strict locals
+### Rendering slots
 
-> _Docs coming soon..._
+> _Docs coming soon..._ 
 
-## Slotify API
+### Slot value objects
 
 > _Docs coming soon..._ 
 
@@ -129,11 +251,8 @@ 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)!
 
-<br>
-
 --- 
 
-<br>
 <a name="full-example" id="full-example"></a>
 
 ## A more full-featured example
@@ -149,7 +268,7 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
     <%= 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" %>
 
@@ -175,7 +294,7 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
 
 <% if items.any? %>
   <%= tag.ul class: "list" do %>
-    <%= partial.li items, class: "list-item" %>
+    <%= content_tag :li, items, class: "list-item" %>
   <% end %>
 <% end %>
 ```

data/lib/slotify/{slotify_helpers.rb → concerns/helpers_concern.rb}

@@ -1,14 +1,12 @@
 module Slotify
-  module SlotifyHelpers
-    def slotify_helpers(*method_names)
+  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 = Utils.with_resolved_args(args, kwargs, block) do
-            super(*_1, **_2.to_h, &_3 || block)
-          end
 
+          results = MethodArgsResolver.call(args, kwargs, block) { super(*_1, **_2, &_3) }
           results.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
         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

@@ -2,18 +2,15 @@ module Slotify
   class UnknownSlotError < NameError
   end
 
-  class MissingRequiredSlotError < ArgumentError
-  end
-
-  class MultipleSlotEntriesError < ArgumentError
-  end
-
   class SlotsAccessError < RuntimeError
   end
 
   class UndefinedSlotError < StandardError
   end
 
+  class MultipleSlotEntriesError < ArgumentError
+  end
+
   class SlotArgumentError < ArgumentError
   end
 

data/lib/slotify/extensions/base.rb

@@ -1,12 +1,7 @@
 module Slotify
   module Extensions
     module Base
-      extend SlotifyHelpers
-
-      slotify_helpers(
-        *ActionView::Helpers::UrlHelper.instance_methods(false),
-        *ActionView::Helpers::TagHelper.instance_methods(false)
-      )
+      extend HelpersConcern
 
       attr_reader :partial
 
@@ -31,6 +26,9 @@ module Slotify
       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

@@ -5,7 +5,6 @@ module Slotify
         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)
@@ -32,7 +31,7 @@ module Slotify
       end
 
       def missing_strict_locals_error?(error)
-        (defined?(ActionView::StrictLocalsError) && error.cause.is_a?(ActionView::StrictLocalsError)) ||
+        error.template && (defined?(ActionView::StrictLocalsError) && error.cause.is_a?(ActionView::StrictLocalsError)) ||
           (error.cause.is_a?(ArgumentError) && error.cause.message.match(/missing local/))
       end
     end

data/lib/slotify/extensions/template.rb

@@ -41,9 +41,8 @@ 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}, #{key});"
+          code << "#{key} = partial.content_for(:#{key}, binding.local_variable_get(:#{key}));"
         end
       end
     end

data/lib/slotify/partial.rb

@@ -1,33 +1,33 @@
 module Slotify
   class Partial
-    include Utils
+    include InflectionHelper
 
     attr_reader :outer_partial
 
     def initialize(view_context)
       @view_context = view_context
       @outer_partial = view_context.partial
-      @entries = []
+      @values = []
       @strict_slots = nil
     end
 
     def content_for(slot_name, fallback_value = nil)
-      raise SlotsAccessError, "slot content cannot be accessed from outside the partial" unless slots_defined?
+      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)
 
-      entries = slot_entries(slot_name)
-      if entries.none? && !fallback_value.nil?
-        entries = add_entries(slot_name, to_array(fallback_value))
+      values = slot_values(slot_name)
+      if values.none? && !fallback_value.nil?
+        values = add_values(slot_name, Array(fallback_value))
       end
 
-      singular?(slot_name) ? entries.first : EntryCollection.new(entries)
+      singular?(slot_name) ? values.first : ValueCollection.new(values)
     end
 
     def content_for?(slot_name)
-      raise SlotsAccessError, "slot content cannot be accessed from outside the partial" unless slots_defined?
+      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_entries(slot_name).any?
+      slot_values(slot_name).any?
     end
 
     def capture(*args, &block)
@@ -43,7 +43,16 @@ module Slotify
     end
 
     def slot_locals
-      @strict_slots.map { [_1, content_for(_1).presence] }.to_h.compact
+      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)
@@ -51,24 +60,19 @@ module Slotify
       validate_slots!
     end
 
-    def helpers
-      @helpers || Helpers.new(@view_context)
-    end
-
     def respond_to_missing?(name, include_private = false)
-      name.start_with?("with_") || helpers.respond_to?(name)
+      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_entry(slot_name, args, options, block)
+          add_value(slot_name, args, options, block)
         else
-          add_entries(slot_name, args.first, options, block)
+          collection = args.first
+          add_values(slot_name, collection, options, block)
         end
-      else
-        helpers.public_send(name, *args, **options, &block)
       end
     end
 
@@ -82,31 +86,29 @@ module Slotify
       slot_name && slots_defined? && @strict_slots.include?(slot_name.to_sym)
     end
 
-    def slot_entries(slot_name)
-      @entries.filter { _1.slot_name == singularize(slot_name) }
+    def slot_values(slot_name)
+      @values.filter { _1.slot_name == singularize(slot_name) }
     end
 
-    def add_entries(slot_name, collection, options = {}, block = nil)
-      unless collection.respond_to?(:each)
-        raise ArgumentError, "expected array to be passed to slot :#{slot_name} (received #{collection.class.name})"
-      end
-
-      collection.map { add_entry(slot_name, _1, options, block) }
+    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_entry(slot_name, args = [], options = {}, block = nil)
-      with_resolved_args(args, options, block) do |rargs, roptions, rblock|
-        @entries << Entry.new(@view_context, singularize(slot_name), rargs, roptions, rblock)
+    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
 
-      @entries.last
+      @values.last
     end
 
     def validate_slots!
       return if @strict_slots.nil?
 
       singular_slots = @strict_slots.map { singularize(_1) }
-      slots_called = @entries.map(&:slot_name).uniq
+      slots_called = @values.map(&:slot_name).uniq
       undefined_slots = slots_called - singular_slots
 
       if undefined_slots.any?
@@ -114,8 +116,8 @@ module Slotify
       end
 
       @strict_slots.filter { singular?(_1) }.each do |slot_name|
-        entries = slot_entries(slot_name)
-        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{entries.size} times (expected 1)" if entries.many?
+        values = slot_values(slot_name)
+        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{values.size} times (expected 1)" if values.many?
       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/{entry.rb → value.rb}

@@ -1,22 +1,22 @@
 module Slotify
-  class Entry
-    include Utils
+  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, **kwargs)
+    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
+      @options = options.to_h
       @block = block
       @partial_path = partial_path
     end
 
     def options
-      EntryOptions.new(@view_context, @options)
+      ValueOptions.new(@view_context, @options)
     end
 
     def content
@@ -52,12 +52,12 @@ module Slotify
     alias_method :to_hash, :to_h
 
     def with_partial_path(partial_path)
-      Entry.new(@view_context, @slot_name, @args, options.to_h, @block, partial_path:)
+      Value.new(@view_context, @slot_name, @args, options, @block, partial_path:)
     end
 
     def with_default_options(default_options)
-      options = merge_tag_options(default_options, @options)
-      Entry.new(@view_context, @slot_name, @args, options.to_h, @block)
+      options = TagOptionsMerger.call(default_options, @options)
+      Value.new(@view_context, @slot_name, @args, options, @block)
     end
 
     def respond_to_missing?(name, include_private = false)

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/{entry_options.rb → value_options.rb}

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

data/lib/slotify/version.rb

@@ -1,3 +1,3 @@
 module Slotify
-  VERSION = "0.0.1.alpha.0"
+  VERSION = "0.0.1"
 end

data/lib/slotify.rb

@@ -6,14 +6,16 @@ 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
 
-module Slotify
-end
-
 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slotify
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Mark Perkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 2025-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -46,18 +46,18 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/slotify.rb
-- lib/slotify/entry.rb
-- lib/slotify/entry_collection.rb
-- lib/slotify/entry_options.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/helpers.rb
 - lib/slotify/partial.rb
-- lib/slotify/slotify_helpers.rb
-- lib/slotify/tag_options_merger.rb
-- lib/slotify/utils.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:
@@ -74,11 +74,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Superpowered slots for your Rails partials.

data/lib/slotify/entry_collection.rb

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

data/lib/slotify/helpers.rb

@@ -1,30 +0,0 @@
-module Slotify
-  class Helpers
-    include Utils
-
-    def initialize(view_context)
-      @view_context = view_context
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      @view_context.respond_to?(name) || @view_context.tag.respond_to?(name)
-    end
-
-    def method_missing(name, *args, **options, &block)
-      results = with_resolved_args(args, options, block) do |rargs, roptions, rblock|
-        call_helper(name, *rargs, **roptions.to_h, &rblock)
-      end
-      results.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
-    end
-
-    private
-
-    def call_helper(name, ...)
-      if @view_context.respond_to?(name)
-        @view_context.public_send(name, ...)
-      else
-        @view_context.tag.public_send(name, ...)
-      end
-    end
-  end
-end

data/lib/slotify/utils.rb

@@ -1,50 +0,0 @@
-module Slotify
-  module Utils
-    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
-
-    def to_array(input)
-      input.is_a?(Array) ? input : [input]
-    end
-
-    def merge_tag_options(...)
-      TagOptionsMerger.call(...)
-    end
-
-    def with_resolved_args(args = [], options = {}, block = nil)
-      args = args.is_a?(Array) ? args.clone : [args]
-      entry_index = args.index { _1.is_a?(EntryCollection) || _1.is_a?(Entry) }
-      if entry_index.nil?
-        [yield(args, options, block)]
-      else
-        target = args[entry_index]
-        entries = target.is_a?(EntryCollection) ? target : [target]
-        entries.map do |entry|
-          cloned_args = args.clone
-          cloned_args[entry_index, 1] = entry.args.clone
-
-          yield(
-            cloned_args,
-            merge_tag_options(options, entry.options),
-            entry.block || block
-          )
-        end
-      end
-    end
-
-    module_function :merge_tag_options
-    module_function :with_resolved_args
-  end
-end