slotify 0.0.0 → 0.0.1.alpha.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 905eaee14b280c6b59fed9887ab8ecf8e1796ca341296debf5c532bbb83ccd5f
-  data.tar.gz: a260b0e8f3eda211a58f48ac5389ebebc84935888fcf6355a00145338005f33f
+  metadata.gz: 3b774ed1d3d704f77cbeebc55d117488eb70f52c1a00527dda727d6cb9100d72
+  data.tar.gz: b8c6ce6b033715c768315671e6d3547925943825a100f5ea67e11d7df7b81ba6
 SHA512:
-  metadata.gz: 5a4b87a2792a032cde484a793dea94025f091a1bfa2464938437dda769ada354b788193aa896831da5d10e1506d8ada25e6a41287cfd9ff539eda3447c88a7f0
-  data.tar.gz: 714fcfd6cfa44f24c7c562f72edaf5833e8b25048d5de639b753f9359c97c7fa0586abb478200ea1a4c5700dbf8774b7e7623a25697084cf8674dc487b9a23e6
+  metadata.gz: ad4a579d74c471684a40b0d60cd8362325cb529d13a362c73d23f5aa67f7383d8d4c9853ebe3e9e4120a31126c4a0069688c924a38ceb8ae0d857e0ba3935b59
+  data.tar.gz: c64f9c44d9880d0488acac9bcc0a4882780b1517024ac86c3b73177f287817bf70ea52d036b74516c0e3f7a4681453acdfccda46b1d9b98ca80f011a09857ebf

data/README.md

@@ -1,81 +1,142 @@
-<img src=".github/assets/slotify_wordmark.svg" width="140">
-  
-
+<img src=".github/assets/slotify_wordmark.svg" width="200">
 
-#### _A superpowered slot system for Rails partials._
+#### Superpowered slots for ActionView partials
 
 ----------
 
-## Overview
+## Overview 
 
-Slotify adds a lightweight (but powerful!) slot system for providing content to partials when rendering them.
+Slotify adds an unobtrusive but powerful **content slot API** to ActionView partials.
 
-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.
+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.
 
-```erb
-<!-- views/_my_partial_.html.erb -->
+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/).
 
-<%# slots: (title: "Example title", items: nil, link:) -%>
+### 
 
-<div>
-  <h1><%= title %></h1>
+## Slotify basics
 
-  <% if items.any? %>
-    <ul>
-      <%= items.each do |item| %>
-        <li <%= item.options %>>
-          <%= item %>
-        </li>
-      <% end%>
-    </ul>
-  <% end %>
+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)).
 
-  <p>
-    Example link: <%= partial.link_to link, class: "example-link" %>
-  </p>
-</div>
+```erb
+<%# slots: (slot_name: "default value", optional_slot_name: nil, required_slot_name:) -%>
 ```
 
-Content can then be provided to slots when rendering the partial:
+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
-<%= render "my_partial", do |partial| %>
-  <%= partial.with_title do %>
-    This is a title
+<!-- _article.html.erb -->
+
+<%# slots: (heading: "Default title", body: nil) -%>
+
+<article>
+  <h1><%= heading %></h1>
+  <% if body.present? %>
+    <div>
+      <%= body %>
+    </div>
   <% end %>
+</article>
+```
+
+> [!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!)._
 
-  <%= partial.with_item "Item 1" %>
-  <%= partial.with_item "Item 2", class: "text-green-700" %>
+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 -->
 
-  <% partial.with_link "example.com", "https://example.com", target: "_blank" %>
+<%= 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 %>
 ```
 
-Slots defined with singular names can only be called with content once whereas slots defined with plural names can be called multiple times.
+> [!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)._
 
-### Requirements
+The example above just scratches the surface of what Slotify slots can do.
 
-* `Rails 8.0+`
-* `Ruby 3.1+`
+You can [jump to a more full-featured example here](#full-example) or read on to learn more...
 
-## Usage
+## Single vs multiple value slots
 
- 🚧 Work in progress! 🚧
+> _Docs coming soon..._ 
 
-### Defining slots
+## Slot arguments and options
 
-Slots are defined using a `strict locals`-style magic comment at the top of the partial template.
+> _Docs coming soon..._ 
 
-```erb
-<%# slots: (title: "Example title", lists: nil, quotes: nil, website_link:) -%>
+## Using helpers with slots
+
+> _Docs coming soon..._ 
+
+## Rendering slot contents
+
+> _Docs coming soon..._ 
+
+<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.
+
+> _Docs coming soon..._ 
+
+### Required slots
+
+> _Docs coming soon..._ 
+
+### Optional slots
+
+> _Docs coming soon..._ 
+
+### Setting default values
+
+> _Docs coming soon..._ 
+
+### Using alongside strict locals
+
+> _Docs coming soon..._
+
+## Slotify API
+
+> _Docs coming soon..._ 
+
+## Installation
+
+Add the following to your Rails app Gemfile:
+
+```rb
+gem "slotify"
 ```
 
-* 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.
+And then run `bundle install`. You are good to go!
 
-### A more complete example
+## 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)!
+
+<br>
+
+--- 
+
+<br>
+<a name="full-example" id="full-example"></a>
+
+## A more full-featured example
 
 ```erb
 <!-- views/_example.html.erb -->
@@ -145,6 +206,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/entry.rb

@@ -0,0 +1,83 @@
+module Slotify
+  class Entry
+    include Utils
+
+    attr_reader :slot_name, :args, :block
+
+    delegate :presence, to: :@content
+
+    def initialize(view_context, slot_name, args = [], options = {}, block = nil, partial_path: nil, **kwargs)
+      @view_context = view_context
+      @slot_name = slot_name.to_sym
+      @args = args
+      @options = options
+      @block = block
+      @partial_path = partial_path
+    end
+
+    def options
+      EntryOptions.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)
+      Entry.new(@view_context, @slot_name, @args, options.to_h, @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)
+    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/entry_collection.rb

@@ -0,0 +1,31 @@
+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/entry_options.rb

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

data/lib/slotify/error.rb

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

data/lib/slotify/extensions/base.rb

@@ -0,0 +1,36 @@
+module Slotify
+  module Extensions
+    module Base
+      extend SlotifyHelpers
+
+      slotify_helpers(
+        *ActionView::Helpers::UrlHelper.instance_methods(false),
+        *ActionView::Helpers::TagHelper.instance_methods(false)
+      )
+
+      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
+    end
+  end
+end

data/lib/slotify/extensions/partial_renderer.rb

@@ -0,0 +1,40 @@
+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)
+        (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,51 @@
+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}, #{key});"
+        end
+      end
+    end
+  end
+end

data/lib/slotify/helpers.rb

@@ -0,0 +1,30 @@
+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/partial.rb

@@ -0,0 +1,122 @@
+module Slotify
+  class Partial
+    include Utils
+
+    attr_reader :outer_partial
+
+    def initialize(view_context)
+      @view_context = view_context
+      @outer_partial = view_context.partial
+      @entries = []
+      @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 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))
+      end
+
+      singular?(slot_name) ? entries.first : EntryCollection.new(entries)
+    end
+
+    def content_for?(slot_name)
+      raise SlotsAccessError, "slot content 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?
+    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
+      @strict_slots.map { [_1, content_for(_1).presence] }.to_h.compact
+    end
+
+    def with_strict_slots(strict_slot_names)
+      @strict_slots = strict_slot_names.map(&:to_sym)
+      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)
+    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)
+        else
+          add_entries(slot_name, args.first, options, block)
+        end
+      else
+        helpers.public_send(name, *args, **options, &block)
+      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_entries(slot_name)
+      @entries.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) }
+    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)
+      end
+
+      @entries.last
+    end
+
+    def validate_slots!
+      return if @strict_slots.nil?
+
+      singular_slots = @strict_slots.map { singularize(_1) }
+      slots_called = @entries.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|
+        entries = slot_entries(slot_name)
+        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{entries.size} times (expected 1)" if entries.many?
+      end
+    end
+  end
+end

data/lib/slotify/slotify_helpers.rb

@@ -0,0 +1,18 @@
+module Slotify
+  module SlotifyHelpers
+    def slotify_helpers(*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.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
+        end
+      end
+      prepend proxy
+    end
+  end
+end

data/lib/slotify/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/utils.rb

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

data/lib/slotify/version.rb

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

data/lib/slotify.rb

@@ -1,3 +1,19 @@
+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.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

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: slotify
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1.alpha.0
 platform: ruby
 authors:
 - Mark Perkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-31 00:00:00.000000000 Z
-dependencies: []
+date: 2025-04-04 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/entry.rb
+- lib/slotify/entry_collection.rb
+- lib/slotify/entry_options.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/version.rb
 homepage:
 licenses:
@@ -34,12 +74,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: A superpowered slot system for Rails partials.
+summary: Superpowered slots for your Rails partials.
 test_files: []