phlex-slotable 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e928c0d1e4cec5220e01d3e6b06ebc5fef4b50ed8f43bdf3634e89f91d201f'
-  data.tar.gz: 726cadd0901159f4cdb083d80300658b44b00da06515946f38fc3701b2ea019b
+  metadata.gz: 7ed2552d628d6851db0da87a5105818d55b5a28bda04d7b5dd9dc0f6fe7357a5
+  data.tar.gz: dd6b66cb419fae64ee1ea963670735a3773a6d1c26bf18c2cc1be01ad43e559b
 SHA512:
-  metadata.gz: 42f10716289705dd92edc63b31637781f490eb02348a6f17911229a5798a31e7a7bc905c990c6b3770cbf5b1bd31110279c509649ac25f16c1b449bc757a4cdf
-  data.tar.gz: 9c050854b88de83f4a4edbbf2ea8c05cf34938d89c5bb0a8b9c4a056c84363c93582091afa3b6f2a91f393dffcf262a6f8f81a936d229c4edfff2ad779724533
+  metadata.gz: 0aafc0d75f3907534255f8ffdc8800e8541373884c5e149afc12dfd5f1e811644c6f037ec32640501f8faec83dace3ea6368c6a17c51fe88b2e27557813f4b70
+  data.tar.gz: a5d11b19a175d1228c0ec7561986dbec0f0a976829b0b0300d599c15d32e801d9afcd4fd2dabdd3a180efccf2f12bde9673ee84744c712fa9aca7b77f3a8e412

data/.standard.yml

@@ -1,3 +1,5 @@
 # For available configuration options, see:
 #   https://github.com/standardrb/standard
-ruby_version: 3.0
+ruby_version: 3.3
+format: progress
+parallel: true

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 ## [Unreleased]
 
+## [0.3.1] - 2024-02-14
+- Support Ruby 2.7
+
+  *stephannv*
+
+## [0.3.0] - 2024-02-14
+
+- Match Slotable peformance with DeferredRender
+  ```
+  ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+  Warming up --------------------------------------
+              Deferred    26.779k i/100ms
+        Slotable 0.2.0     21.636k i/100ms
+        Slotable 0.3.0    27.013k i/100ms
+  Calculating -------------------------------------
+              Deferred    267.884k (± 0.6%) i/s -      1.366M in   5.098391s
+        Slotable 0.2.0    216.193k (± 0.4%) i/s -      1.082M in   5.003961s
+        Slotable 0.3.0    270.082k (± 0.5%) i/s -      1.351M in   5.001001s
+  ```
+  *stephannv*
+
+- Allow polymorphic slots
+  ```ruby
+  class CardComponent < Phlex::HTML
+    include Phlex::Slotable
+
+    slot :avatar, types: { icon: IconComponent, image: ImageComponent }
+
+    def template
+      if avatar_slot?
+        render avatar_slot
+      end
+    end
+  end
+
+  render CardComponent.new do |card|
+    if user
+      card.with_image_avatar(src: user.image_url)
+    else
+      card.with_icon_avatar(name: :user)
+    end
+  end
+  ```
+
+  *stephannv*
+
 ## [0.2.0] - 2024-02-13
 
 - Allow view slots using string as class name

data/README.md

@@ -2,6 +2,7 @@
 > Please note that Phlex::Slotable is currently under development and may undergo changes to its API before reaching the stable release (1.0.0). As a result, there may be breaking changes that affect its usage.
 
 # Phlex::Slotable
+[![CI](https://github.com/stephannv/phlex-slotable/actions/workflows/main.yml/badge.svg)](https://github.com/stephannv/phlex-slotable/actions/workflows/main.yml)
 
 Phlex::Slotable enables slots feature to [Phlex](https://www.phlex.fun/) views. Inspired by ViewComponent.
 
@@ -252,7 +253,7 @@ class MyPage < Phlex::HTML
 end
 ```
 
-You can access the internal view state within lambda slots.For example:
+You can access the internal view state within lambda slots. For example:
 ```ruby
 class BlogComponent < Phlex::HTML
   include Phlex::Slotable
@@ -273,10 +274,84 @@ class MyPage < Phlex::HTML
 end
 ```
 
+#### Polymorphic slots
+Polymorphic slots can render one of several possible slots, allowing for flexibility in component content. This feature is particularly useful when you require a fixed structure but need to accommodate different types of content. To implement this, simply pass a types hash containing the types along with corresponding slot definitions.
+
+```ruby
+class CardComponent < Phlex::HTML
+  include Phlex::Slotable
+
+  slot :avatar, types: { icon: IconComponent, image: ImageComponent }
+
+  def template
+    if avatar_slot?
+      figure id: "avatar" do
+        render avatar_slot
+      end
+    end
+  end
+end
+```
+
+This allows you to set the icon slot using `with_icon_avatar` or the image slot using `with_image_avatar`:
+```ruby
+class UserCardComponent < Phlex::HTML
+  def initialize(user:)
+    @user = user
+  end
+
+  def template
+    render CardComponent.new do |card|
+      if @user.image?
+        card.with_image_avatar(src: @user.image)
+      else
+        card.with_icon_avatar(name: :user)
+      end
+    end
+  end
+end
+```
+
+Please note that you can still utilize the other slot definition APIs:
+```ruby
+class CardComponent < Phlex::HTML
+  include Phlex::Slotable
+
+  slot :avatar, types: {
+    icon: IconComponent,
+    image: "ImageComponent",
+    text: ->(size:, &content) { span(class: "text-#{size}", &content) }
+  }, many: true
+
+  def template
+    if avatar_slots?
+      avatar_slots.each do |slot|
+        render slot
+      end
+    end
+
+    span { "Count: #{avatar_slots.size}" }
+  end
+
+  ...
+end
+
+class UsersCardComponent < Phlex::HTML
+  def template
+    render CardComponent.new do |card|
+      card.with_image_avatar(src: @user.image)
+      card.with_icon_avatar(name: :user)
+      card.with_text_avatar(size: :lg) { "SV" }
+    end
+  end
+end
+```
+
+
 ## Roadmap
 - ✅ ~~Accept Strings as view class name~~
 - ✅ ~~Allow lambda slots~~
-- 🕐 Allow polymorphic slots
+- ✅ ~~Allow polymorphic slots~~
 
 ## Development
 

data/benchmark/main.rb

@@ -0,0 +1,106 @@
+require "benchmark"
+require "benchmark/ips"
+require_relative "../lib/phlex/slotable"
+
+class DeferredList < Phlex::HTML
+  include Phlex::DeferredRender
+
+  def initialize
+    @items = []
+  end
+
+  def template
+    if @header
+      h1(class: "header", &@header)
+    end
+
+    ul do
+      @items.each do |item|
+        li { render(item) }
+      end
+    end
+  end
+
+  def header(&block)
+    @header = block
+  end
+
+  def with_item(&content)
+    @items << content
+  end
+end
+
+class SlotableList < Phlex::HTML
+  include Phlex::Slotable
+
+  slot :header
+  slot :item, many: true
+
+  def template
+    if header_slot
+      h1(class: "header", &header_slot)
+    end
+
+    ul do
+      item_slots.each do |slot|
+        li { render(slot) }
+      end
+    end
+  end
+end
+
+class DeferredListExample < Phlex::HTML
+  def template
+    render DeferredList.new do |list|
+      list.header do
+        "Header"
+      end
+
+      list.with_item do
+        "One"
+      end
+
+      list.with_item do
+        "two"
+      end
+    end
+  end
+end
+
+class SlotableListExample < Phlex::HTML
+  def template
+    render SlotableList.new do |list|
+      list.with_header do
+        "Header"
+      end
+
+      list.with_item do
+        "One"
+      end
+
+      list.with_item do
+        "two"
+      end
+    end
+  end
+end
+
+puts RUBY_DESCRIPTION
+
+deferred_list = DeferredListExample.new.call
+slotable_list = SlotableListExample.new.call
+
+raise unless deferred_list == slotable_list
+
+Benchmark.bmbm do |x|
+  x.report("Deferred") { 1_000_000.times { DeferredListExample.new.call } }
+  x.report("Slotable") { 1_000_000.times { SlotableListExample.new.call } }
+end
+
+puts
+
+Benchmark.ips do |x|
+  x.report("Deferred") { DeferredListExample.new.call }
+  x.report("Slotable") { SlotableListExample.new.call }
+  x.compare!
+end

data/lib/phlex/slotable/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Slotable
-    VERSION = "0.2.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/phlex/slotable.rb

@@ -9,63 +9,97 @@ module Phlex
     end
 
     module ClassMethods
-      def slot(slot_name, callable = nil, many: false)
+      def slot(slot_name, callable = nil, types: nil, many: false)
         include Phlex::DeferredRender
 
-        if callable.is_a?(Proc)
-          define_method :"__call_#{slot_name}__", &callable
-          private :"__call_#{slot_name}__"
+        if types
+          types.each do |type, callable|
+            define_setter_method(slot_name, callable, many: many, type: type)
+          end
+        else
+          define_setter_method(slot_name, callable, many: many)
         end
+        define_predicate_method(slot_name, many: many)
+        define_getter_method(slot_name, many: many)
+      end
 
-        if many
-          define_method :"with_#{slot_name}" do |*args, **kwargs, &block|
-            instance_variable_set(:"@#{slot_name}_slots", []) unless instance_variable_defined?(:"@#{slot_name}_slots")
+      private
 
-            value = case callable
-            when nil
-              block
-            when String
-              self.class.const_get(callable).new(*args, **kwargs, &block)
-            when Proc
-              -> { self.class.instance_method(:"__call_#{slot_name}__").bind_call(self, *args, **kwargs, &block) }
-            else
-              callable.new(*args, **kwargs, &block)
+      def define_setter_method(slot_name, callable, many:, type: nil)
+        slot_name_with_type = type ? "#{type}_#{slot_name}" : slot_name
+
+        setter_method = if many
+          <<-RUBY
+            def with_#{slot_name_with_type}(*args, **kwargs, &block)
+              @#{slot_name}_slots ||= []
+              @#{slot_name}_slots << #{callable_value(slot_name_with_type, callable)}
+            end
+          RUBY
+        else
+          <<-RUBY
+            def with_#{slot_name_with_type}(*args, **kwargs, &block)
+              @#{slot_name}_slot = #{callable_value(slot_name_with_type, callable)}
             end
+          RUBY
+        end
 
-            instance_variable_get(:"@#{slot_name}_slots") << value
-          end
+        class_eval(setter_method, __FILE__, __LINE__ + 1)
+        define_lambda_method(slot_name_with_type, callable) if callable.is_a?(Proc)
+      end
 
-          define_method :"#{slot_name}_slots?" do
-            !send(:"#{slot_name}_slots").empty?
-          end
-          private :"#{slot_name}_slots?"
+      def define_lambda_method(slot_name, callable)
+        define_method :"__call_#{slot_name}__", &callable
+        private :"__call_#{slot_name}__"
+      end
 
-          define_method :"#{slot_name}_slots" do
-            instance_variable_get(:"@#{slot_name}_slots") || instance_variable_set(:"@#{slot_name}_slots", [])
-          end
-          private :"#{slot_name}_slots"
+      def define_getter_method(slot_name, many:)
+        getter_method = if many
+          <<-RUBY
+            def #{slot_name}_slots
+              @#{slot_name}_slots ||= []
+            end
+            private :#{slot_name}_slots
+          RUBY
         else
-          define_method :"with_#{slot_name}" do |*args, **kwargs, &block|
-            value = case callable
-            when nil
-              block
-            when String
-              self.class.const_get(callable).new(*args, **kwargs, &block)
-            when Proc
-              -> { self.class.instance_method(:"__call_#{slot_name}__").bind_call(self, *args, **kwargs, &block) }
-            else
-              callable.new(*args, **kwargs, &block)
+          <<-RUBY
+            def #{slot_name}_slot
+              @#{slot_name}_slot
             end
+            private :#{slot_name}_slot
+          RUBY
+        end
 
-            instance_variable_set(:"@#{slot_name}_slot", value)
-          end
+        class_eval(getter_method, __FILE__, __LINE__ + 1)
+      end
 
-          define_method :"#{slot_name}_slot?" do
-            !instance_variable_get(:"@#{slot_name}_slot").nil?
-          end
-          private :"#{slot_name}_slot?"
+      def define_predicate_method(slot_name, many:)
+        predicate_method = if many
+          <<-RUBY
+            def #{slot_name}_slots?
+              #{slot_name}_slots.any?
+            end
+            private :#{slot_name}_slots?
+          RUBY
+        else
+          <<-RUBY
+            def #{slot_name}_slot?
+              !#{slot_name}_slot.nil?
+            end
+            private :#{slot_name}_slot?
+          RUBY
+        end
 
-          attr_reader :"#{slot_name}_slot"
+        class_eval(predicate_method, __FILE__, __LINE__ + 1)
+      end
+
+      def callable_value(slot_name, callable)
+        case callable
+        when nil
+          %(block)
+        when Proc
+          %(-> { self.class.instance_method(:"__call_#{slot_name}__").bind_call(self, *args, **kwargs, &block) })
+        else
+          %(#{callable}.new(*args, **kwargs, &block))
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phlex-slotable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - stephann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-13 00:00:00.000000000 Z
+date: 2024-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex
@@ -37,6 +37,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/main.rb
 - lib/phlex/slotable.rb
 - lib/phlex/slotable/version.rb
 homepage: https://github.com/stephannv/phlex-slotable