slotify 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3528c82a3e01b2acc454f5df4c8081f19157e975a2e2ddaa46f56dadc565426f
-  data.tar.gz: e9660ecb767e9ec12156eb3e878f10cdf9fe74c8b67b9fbc574fa64cae1f5f1a
+  metadata.gz: 311b3b7001fb194c8518283b714ed8f5ed5990dc5b7fa51af34a25348f00d8cd
+  data.tar.gz: d22c0b5cea41b792e837f387b6c444013ff64013b84bcf781aa67f46e91a9e6c
 SHA512:
-  metadata.gz: fe68d4ff07cbc1a12cc69937bb0da7af4080082504226f7dd9c63a8f4b35461460671265ca09745a9899e6e49ac5aab0c377a83d795a2547eb423255907aa84d
-  data.tar.gz: a189cd09e36a1eab05de32a1c62f953acbe72dcca1ed64c0dd058002ded2f8da2d828e95e0ba0b7865a29d3cac4c58a1cc9c7ad45679ce87684a8edfe03e1032
+  metadata.gz: 8cb049942e918fb670d775d9e7e6fe42a4db1b799d6df34a4ed7ea6dbb6f325824d52a56f629d379597e8273b3c02d6151749e6de01d7019def944b627bbc828
+  data.tar.gz: 70658ea93b6b19b14a0a608e6d3afc9e815a9f3c70fdfdd7a9d5ec20a9743b4fcb3603e6c2973381e7219cf4b39dd65e42448be5874446780a8c020055923061

data/README.md

@@ -269,11 +269,11 @@ When rendered as a string the options are passed through the Rails `tag.attribut
 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**.
+* **Multi-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:
+Single-value slots are defined using a **singular** slot name:
 
 ```erb
 <%# slots: (item: nil) -%>
@@ -305,18 +305,18 @@ and their corresponding template variable represents a single value:
 > <% end %>
 > ```
 
-#### Multiple-value slots
+#### Multi-value slots
 
-Multiple-value slots are defined using a **plural** slot name:
+Multi-value slots are defined using a **plural** slot name:
 
 ```erb
 <%# slots: (items: nil) -%>
 ```
 
-Multiple-value slots can be called as many times as needed
+Multi-value slots can be called as many times as needed
 and their corresponding template variable represents an array of values.
 
-The slot writer methods for multiple-value slots use the **singluar form** of the slot name (e.g. `#with_item` for the `items` slot).
+The slot writer methods for multi-value slots use the **singluar form** of the slot name (e.g. `#with_item` for the `items` slot).
 
 ```erb
 <%= render "example" do |partial| %>
@@ -371,8 +371,6 @@ The slot writer methods for multiple-value slots use the **singluar form** of th
 **Singlular slot value variables** in partial templates are actually instances of `Slotity::Value`.
 These value objects are automatically stringified so in most cases you will not even be aware of this and they can just be treated as regular string variables.
 
-
-
 ```erb
 <%= render "example" do |partial| %>
   <% partial.with_title class: "color-hotpink" do %>
@@ -448,7 +446,7 @@ However there are a number of key differences:
 Nice partials slots are implicitly defined when rendering the partial.
 * Slotify slot values are available as local variables;
 with Nice partials slot values are accessed via methods on the `partial` variable.
-* Slotify has the concept (and enforces the use) of single-value vs. multiple-value slots.
+* Slotify has the concept (and enforces the use) of single- vs. multi-value slots.
 * Slotify slot content and options are transparently expanded and merged into defaults when using with helpers like `content_tag` and `link_to`.
 * Slotify slot values are `renderable` objects
 
@@ -458,7 +456,7 @@ separation of 'nice partial' functionality from ActionView-provided locals etc.
 #### `view_component`
 
 Both [ViewComponent](https://viewcomponent.org/) and Slotify provide a 'slots' API for content blocks.
-Slotify's slot writer syntax (i.e. `.with_<slot_name>` methods) and the concept of single-value (`renders_one`) vs multiple-value (`renders_many`) slots
+Slotify's slot writer syntax (i.e. `.with_<slot_name>` methods) and the concept of single-value (`renders_one`) vs multi-value (`renders_many`) slots
 are both modelled on ViewComponent's slots implementation.
 
 However apart from that they are quite different. Slotify adds functionality to regular ActionView partials whereas ViewComponent provides a complete standalone component system.
@@ -484,78 +482,99 @@ And then run `bundle install`. You are good to go!
 * `Rails 7.1+`
 * `Ruby 3.1+`
 
-## Credits
+## Testing 
 
-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).
+Slotify uses MiniTest for its test suite.
+
+[Appraisal](https://github.com/thoughtbot/appraisal) is used in CI to test against a matrix of Ruby/Rails versions.
 
-`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)!
+#### Run tests
 
-## Benchmarks
+```shell
+bin/test
+```
 
-Slotify is still in the early stages of development and no attempt has yet been made to optimise rendering performance.
+### Benchmarks
 
-Below are some initial (crude) benchmarking comparisons with other similar gems.
+Rendering performance benchmark tests for Slotify and a few alternatives (`action_view`, `view_component` & `nice_partials`) can be found in the `/performance` directory.
 
-> [!TIP]
-> Benchmarks can be run using the `bin/benchmarks` command from the repository root.
+These benchmarks are a little crude right now!
+
+**Run benchmarks:**
 
+```shell
+bin/benchmarks # run all benchmarks
+bin/benchmarks slotify # run Slotify benchmarks only
 ```
-✨🦄 ACTION_VIEW 🦄✨
+
+<details>
+<summary>Recent benchmark results</summary>
+
+```
+🏁🏁 ACTION_VIEW 🏁🏁
 
 ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
 Warming up --------------------------------------
-            no slots    12.997k i/100ms
-               slots    10.891k i/100ms
+            no slots    13.120k i/100ms
+               slots    11.038k i/100ms
 Calculating -------------------------------------
-            no slots    125.622k (± 5.4%) i/s    (7.96 μs/i) -      1.261M in  10.072521s
-               slots    108.468k (± 3.3%) i/s    (9.22 μs/i) -      1.089M in  10.053026s
+            no slots    127.047k (± 5.2%) i/s    (7.87 μs/i) -      1.273M in  10.051203s
+               slots    106.400k (± 5.0%) i/s    (9.40 μs/i) -      1.071M in  10.095061s
 
 Comparison:
-            no slots:   125621.9 i/s
-               slots:   108467.5 i/s - 1.16x  slower
+            no slots:   127047.3 i/s
+               slots:   106400.3 i/s - 1.19x  slower
 
 
-✨🦄 NICE_PARTIALS 🦄✨
+🏁🏁 NICE_PARTIALS 🏁🏁
 
 ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
 Warming up --------------------------------------
-            no slots    11.822k i/100ms
-               slots     4.204k i/100ms
+            no slots    11.451k i/100ms
+               slots     3.889k i/100ms
 Calculating -------------------------------------
-            no slots    114.190k (± 4.7%) i/s    (8.76 μs/i) -      1.147M in  10.069870s
-               slots     41.138k (± 4.3%) i/s   (24.31 μs/i) -    411.992k in  10.039730s
+            no slots    117.258k (± 3.3%) i/s    (8.53 μs/i) -      1.179M in  10.070693s
+               slots     40.737k (± 4.5%) i/s   (24.55 μs/i) -    408.345k in  10.051584s
 
 Comparison:
-            no slots:   114190.2 i/s
-               slots:    41137.9 i/s - 2.78x  slower
+            no slots:   117257.7 i/s
+               slots:    40736.8 i/s - 2.88x  slower
 
 
-✨🦄 VIEW_COMPONENT 🦄✨
+🏁🏁 VIEW_COMPONENT 🏁🏁
 
 ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
 Warming up --------------------------------------
-            no slots    20.329k i/100ms
-               slots     7.409k i/100ms
+            no slots    20.270k i/100ms
+               slots     7.445k i/100ms
 Calculating -------------------------------------
-            no slots    196.288k (± 4.7%) i/s    (5.09 μs/i) -      1.972M in  10.073103s
-               slots     71.311k (± 5.0%) i/s   (14.02 μs/i) -    718.673k in  10.108426s
+            no slots    211.571k (± 2.6%) i/s    (4.73 μs/i) -      2.128M in  10.067334s
+               slots     72.508k (± 5.2%) i/s   (13.79 μs/i) -    729.610k in  10.096809s
 
 Comparison:
-            no slots:   196287.6 i/s
-               slots:    71310.5 i/s - 2.75x  slower
+            no slots:   211570.7 i/s
+               slots:    72508.0 i/s - 2.92x  slower
 
 
-✨🦄 SLOTIFY 🦄✨
+🏁🏁 SLOTIFY 🏁🏁
 
 ruby 3.3.1 (2024-04-23 revision c56cd86388) [arm64-darwin23]
 Warming up --------------------------------------
-            no slots    10.883k i/100ms
-               slots    77.000 i/100ms
+            no slots    12.051k i/100ms
+               slots     2.710k i/100ms
 Calculating -------------------------------------
-            no slots    110.153k (± 4.8%) i/s    (9.08 μs/i) -      1.099M in  10.009002s
-               slots    789.118 (± 4.1%) i/s    (1.27 ms/i) -      7.931k in  10.071749s
+            no slots    116.156k (± 5.4%) i/s    (8.61 μs/i) -      1.169M in  10.102387s
+               slots     26.454k (± 5.4%) i/s   (37.80 μs/i) -    265.580k in  10.077285s
 
 Comparison:
-            no slots:   110152.8 i/s
-               slots:      789.1 i/s - 139.59x  slower
+            no slots:   116155.7 i/s
+               slots:    26454.0 i/s - 4.39x  slower
 ```
+
+</details>
+
+## 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)!

data/lib/slotify/concerns/symbol_inflection_helper.rb

@@ -0,0 +1,19 @@
+module Slotify
+  module SymbolInflectionHelper
+    extend ActiveSupport::Concern
+
+    mattr_accessor :singularizations, default: {}
+
+    def singular?(sym)
+      singularize(sym.to_sym) == sym.to_sym
+    end
+
+    def plural?(sym)
+      !singular?(sym)
+    end
+
+    def singularize(sym)
+      singularizations[sym.to_sym] ||= sym.to_s.singularize.to_sym
+    end
+  end
+end

data/lib/slotify/extensions/base.rb

@@ -5,13 +5,6 @@ module Slotify
 
       attr_accessor :partial
 
-      def render(options = {}, locals = {}, &block)
-        @partial = Slotify::Partial.new(self)
-        super
-      ensure
-        @partial = partial.outer_partial
-      end
-
       def capture_with_outer_partial_access(*args, &block)
         inner_partial, @partial = partial, partial.outer_partial
         inner_partial.capture(*args, &block)

data/lib/slotify/extensions/partial_renderer.rb

@@ -4,17 +4,20 @@ module Slotify
       def render_partial_template(view, locals, template, layout, block)
         return super unless template.strict_slots?
 
-        view.partial.define_slots!(template.strict_slots_keys)
+        view.partial = Slotify::Partial.new(view, template.strict_slots_keys)
 
         view.capture_with_outer_partial_access(&block) if block
+
         locals = locals.merge(view.partial.slot_locals)
 
         decorate_strict_slots_errors do
           super(view, locals, template, layout, block)
         end
+      ensure
+        view.partial = view.partial.outer_partial if view.partial
       end
 
-      def decorate_strict_slots_errors(&block)
+      def decorate_strict_slots_errors
         yield
       rescue ActionView::Template::Error => error
         if missing_strict_locals_error?(error)

data/lib/slotify/extensions/template.rb

@@ -31,7 +31,7 @@ module Slotify
       end
 
       def strict_slots_keys
-        @strict_slots_keys ||= strict_slots!.scan(STRICT_SLOTS_KEYS_REGEX).map(&:first)
+        @strict_slots_keys ||= strict_slots!.scan(STRICT_SLOTS_KEYS_REGEX).map(&:first).freeze
       end
 
       def strict_locals!
@@ -44,7 +44,7 @@ module Slotify
         return super unless strict_slots?
 
         strict_slots_keys.each_with_object(+super) do |key, code|
-          code << "partial.set_slot_default(:#{key}, binding.local_variable_get(:#{key})); #{key} = partial.public_send(:#{key});"
+          code << "partial.set_slot_default(:#{key}, binding.local_variable_get(:#{key})); #{key} = partial.content_for(:#{key});"
         end
       end
     end

data/lib/slotify/partial.rb

@@ -1,6 +1,6 @@
 module Slotify
   class Partial
-    include InflectionHelper
+    include SymbolInflectionHelper
 
     RESERVED_SLOT_NAMES = [
       :content, :slot, :value, :content_for,
@@ -9,11 +9,13 @@ module Slotify
 
     attr_reader :outer_partial
 
-    def initialize(view_context)
+    def initialize(view_context, slots = [])
       @view_context = view_context
       @outer_partial = view_context.partial
       @values = ValueStore.new(@view_context)
       @defined_slots = nil
+
+      define_slots!(slots)
     end
 
     def content_for(slot_name)
@@ -50,8 +52,6 @@ module Slotify
     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
@@ -65,50 +65,56 @@ module Slotify
       end.to_h
     end
 
-    def define_slots!(slot_names)
-      raise SlotsDefinedError, "Slots cannot be redefined" unless @defined_slots.nil?
+    private
 
+    attr_reader :values
+
+    def slot?(slot_name)
+      slot_name && @defined_slots.include?(slot_name.to_sym)
+    end
+
+    def define_slots!(slot_names)
       @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"
+          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_") || slot?(name)
-    end
-
-    def method_missing(name, *args, **options, &block)
-      if name.start_with?("with_")
-        values.add(name.to_s.delete_prefix("with_"), args, options, block)
-      elsif slot?(name)
-        content_for(name)
-      else
-        super
+        if singular?(slot_name)
+          define_single_value_slot_method(slot_name)
+        else
+          define_multi_value_slot_methods(slot_name)
+        end
       end
     end
 
-    private
+    def define_single_value_slot_method(slot_name)
+      method_name = :"with_#{slot_name}"
 
-    attr_reader :values
+      return if respond_to?(method_name)
 
-    def slot?(slot_name)
-      slot_name && @defined_slots.include?(slot_name.to_sym)
+      self.class.define_method(method_name) do |*args, **options, &block|
+        if values.for(slot_name).any?
+          raise MultipleSlotEntriesError,
+            "slot :#{slot_name} is defined as a single-value slot but was called multiple times"
+        end
+
+        values.add(slot_name, args, options, block)
+      end
     end
 
-    def validate_slots!
-      return if @defined_slots.nil?
+    def define_multi_value_slot_methods(slot_name)
+      method_name = :"with_#{slot_name}"
+      singular_slot_name = singularize(slot_name)
+
+      return if respond_to?(method_name)
 
-      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(", ")}`"
+      self.class.define_method(method_name) do |*args, **options, &block|
+        values.add(slot_name, args, options, block)
       end
 
-      @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?
+      self.class.define_method(:"with_#{singular_slot_name}") do |*args, **options, &block|
+        values.add(singular_slot_name, args, options, block)
       end
     end
   end

data/lib/slotify/services/tag_options_merger.rb

@@ -1,53 +1,46 @@
 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
+        mix(original, target)
       end
 
       private
 
-      def merge_data_options(original_data, target_data)
-        original_data = original_data.dup
+      # https://www.phlex.fun/sgml/helpers#mix
+      def mix(*args)
+        args.each_with_object({}) do |object, result|
+          result.merge!(object) do |_key, old, new|
+            case [old, new].freeze
+            in [Array, Array] | [Set, Set]
+              old + new
+            in [Array, Set]
+              old + new.to_a
+            in [Array, String]
+              old + [new]
+            in [Hash, Hash]
+              mix(old, new)
+            in [Set, Array]
+              old.to_a + new
+            in [Set, String]
+              old.to_a + [new]
+            in [String, Array]
+              [old] + new
+            in [String, Set]
+              [old] + new.to_a
+            in [String, String]
+              "#{old} #{new}"
+            in [_, nil]
+              old
+            else
+              new
+            end
+          end
 
-        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
+          result.transform_keys! do |key|
+            key.end_with?("!") ? key.name.chop.to_sym : key
           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

data/lib/slotify/value.rb

@@ -1,6 +1,6 @@
 module Slotify
   class Value
-    include InflectionHelper
+    include SymbolInflectionHelper
 
     attr_reader :slot_name, :args, :block
 
@@ -47,7 +47,7 @@ module Slotify
     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:)
+      Value.new(@view_context, @args, @options, @block, slot_name: @slot_name, partial_path:)
     end
 
     def with_default_options(default_options)
@@ -61,7 +61,7 @@ module Slotify
 
     def method_missing(name, ...)
       if name.start_with?("to_")
-        @args.first.public_send(name, ...)
+        content.public_send(name, ...)
       else
         super
       end
@@ -72,7 +72,7 @@ module Slotify
     end
 
     def render_in(view_context, &block)
-      view_context.render partial_path, **@options.to_h, &@block || block
+      view_context.render partial_path, **@options.to_h, &block || @block
     end
 
     private

data/lib/slotify/value_store.rb

@@ -1,6 +1,6 @@
 module Slotify
   class ValueStore
-    include InflectionHelper
+    include SymbolInflectionHelper
 
     def initialize(view_context)
       @view_context = view_context
@@ -13,11 +13,9 @@ module Slotify
 
     def add(slot_name, args = [], options = {}, block = nil)
       if plural?(slot_name)
-        Array.wrap(args.first).map { add(singularize(slot_name), _1, options, block) }
+        Array.wrap(args.shift).map { add(singularize(slot_name), [_1, *args], options, block) }
       else
-        MethodArgsResolver.call(args, options, block) do
-          @values << Value.new(@view_context, _1, _2, _3, slot_name: singularize(slot_name))
-        end
+        @values << Value.new(@view_context, args, options, block, slot_name: singularize(slot_name))
       end
     end
 

data/lib/slotify/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slotify
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Mark Perkins
@@ -46,8 +46,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/slotify.rb
-- lib/slotify/concerns/inflection_helper.rb
 - lib/slotify/concerns/slot_compatability.rb
+- lib/slotify/concerns/symbol_inflection_helper.rb
 - lib/slotify/error.rb
 - lib/slotify/extensions/base.rb
 - lib/slotify/extensions/partial_renderer.rb
@@ -79,7 +79,7 @@ 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: Superpowered slots for your Rails partials.

data/lib/slotify/concerns/inflection_helper.rb

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