slotify 0.0.1.alpha.0 → 0.0.2

data/lib/slotify/extensions/base.rb

@@ -1,36 +1,26 @@
 module Slotify
   module Extensions
     module Base
-      extend SlotifyHelpers
+      include SlotCompatability
 
-      slotify_helpers(
-        *ActionView::Helpers::UrlHelper.instance_methods(false),
-        *ActionView::Helpers::TagHelper.instance_methods(false)
-      )
+      attr_accessor :partial
 
-      attr_reader :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)
       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

@@ -4,11 +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)
@@ -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

@@ -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!
@@ -43,7 +44,7 @@ module Slotify
         return super unless strict_slots?
 
         strict_slots_keys.each_with_object(+super) do |key, code|
-          code << "#{key} = partial.content_for(:#{key}, #{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

@@ -1,33 +1,32 @@
 module Slotify
   class Partial
-    include Utils
+    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
-      @entries = []
-      @strict_slots = nil
+      @values = ValueStore.new(@view_context)
+      @defined_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
+    def content_for(slot_name)
+      raise UnknownSlotError, "unknown slot :#{slot_name}" unless slot?(slot_name)
 
-      singular?(slot_name) ? entries.first : EntryCollection.new(entries)
+      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 content 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_entries(slot_name).any?
+      values.for(slot_name).any?
     end
 
     def capture(*args, &block)
@@ -35,87 +34,81 @@ module Slotify
     end
 
     def yield(*args)
-      if args.empty?
-        @captured_buffer
-      else
-        content_for(args.first)
-      end
+      args.empty? ? @captured_buffer : content_for(args.first)
     end
 
-    def slot_locals
-      @strict_slots.map { [_1, content_for(_1).presence] }.to_h.compact
+    def content
+      self.yield
     end
 
-    def with_strict_slots(strict_slot_names)
-      @strict_slots = strict_slot_names.map(&:to_sym)
+    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
       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.
+        value.is_a?(String) || value&.present?
+      end.to_h
     end
 
-    def helpers
-      @helpers || Helpers.new(@view_context)
+    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_") || helpers.respond_to?(name)
+      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_entry(slot_name, args, options, block)
-        else
-          add_entries(slot_name, args.first, options, block)
-        end
+        values.add(name.to_s.delete_prefix("with_"), args, options, block)
+      elsif slot?(name)
+        content_for(name)
       else
-        helpers.public_send(name, *args, **options, &block)
+        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
+    attr_reader :values
 
-    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
+    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 = @entries.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|
-        entries = slot_entries(slot_name)
-        raise MultipleSlotEntriesError, "slot :#{slot_name} called #{entries.size} times (expected 1)" if entries.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/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/value.rb

@@ -0,0 +1,84 @@
+module Slotify
+  class Value
+    include InflectionHelper
+
+    attr_reader :slot_name, :args, :block
+
+    delegate :presence, :to_s, :to_str, to: :content
+
+    def initialize(view_context, args = [], options = {}, block = nil, slot_name: 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
+      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
+        args.first
+      end
+    end
+
+    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, @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, @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, ...)
+      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
+
+    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/{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/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.alpha.0"
+  VERSION = "0.0.2"
 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.2
 platform: ruby
 authors:
 - Mark Perkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 2025-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -46,18 +46,19 @@ 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/inflection_helper.rb
+- lib/slotify/concerns/slot_compatability.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/value_store.rb
 - lib/slotify/version.rb
 homepage:
 licenses:
@@ -74,9 +75,9 @@ 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
 signing_key:

data/lib/slotify/entry.rb

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

@@ -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