phlex-slotable 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ed2552d628d6851db0da87a5105818d55b5a28bda04d7b5dd9dc0f6fe7357a5
-  data.tar.gz: dd6b66cb419fae64ee1ea963670735a3773a6d1c26bf18c2cc1be01ad43e559b
+  metadata.gz: 663b35110ae8bfad98b0a05e7a5a30afc296f16fc088b4271499ef02b03b9ba2
+  data.tar.gz: eb7153fef5861841d353e5404498dbbaadb8ad1bc7e7f83d6ae82f9bebc0551e
 SHA512:
-  metadata.gz: 0aafc0d75f3907534255f8ffdc8800e8541373884c5e149afc12dfd5f1e811644c6f037ec32640501f8faec83dace3ea6368c6a17c51fe88b2e27557813f4b70
-  data.tar.gz: a5d11b19a175d1228c0ec7561986dbec0f0a976829b0b0300d599c15d32e801d9afcd4fd2dabdd3a180efccf2f12bde9673ee84744c712fa9aca7b77f3a8e412
+  metadata.gz: 7e7fcf450ddbd8bbab8b6eeb22fa54f0de68d9e5611da5c8c1f71e87bd27d2b7497eecdff21b9d61d40006ea7d1f0f782dfa1b4213284a46e8ae8988b8357394
+  data.tar.gz: ad39d88df8841cd7e7599b50b64d48e9b7faefc9abb44b3856749e728bad37c672dbd09fff420324d6b59257f1aaf65d5aef00af614a9a2f509b71e32fb923b3

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.5.0] - 2025-09-08
+- Prepare for Phlex 2.0 💪
+- Drop Ruby 2.7, 3.0 and 3.1 support
+- Add Phlex::Kit compatibility tests
+- Make `Phlex::Slotable::VERSION` available by default
+
+## [0.4.0] - 2024-02-14
+- [BREAKING CHANGE] Rename `many` option to `collection`.
+
+  *stephannv*
+
+- Improve generic slot performance
+
+  *stephannv*
+
 ## [0.3.1] - 2024-02-14
 - Support Ruby 2.7
 

data/README.md

@@ -6,7 +6,22 @@
 
 Phlex::Slotable enables slots feature to [Phlex](https://www.phlex.fun/) views. Inspired by ViewComponent.
 
-## Installation
+- [What is a slot?](#what-is-a-slot)
+- [Getting started](#getting-started)
+- [Generic slot](#generic-slot)
+- [Slot collection](#slot-collection)
+- [Component slot](#component-slot)
+- [Lambda slot](#lambda-slot)
+- [Polymorphic slot](#polymorphic-slot)
+- [Performance](#performance)
+- [Development](#development)
+- [Contributing](#contributing)
+
+## What is a slot?
+
+In the context of view components, a **slot** serves as a  placeholder inside a component that can be filled with custom content.  Essentially, slots enable a component to accept external content and  autonomously organize it within its structure. This abstraction allows developers to work with components without needing to understand their internals, thereby ensuring visual consistency and improving developer experience.
+
+## Getting started
 
 Install the gem and add to the application's Gemfile by executing:
 
@@ -16,268 +31,272 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install phlex-slotable
 
-## Usage
-
-#### Basic
+> [!TIP]
+> If you prefer not to add another dependency to your project, you can simply copy the [Phlex::Slotable](https://github.com/stephannv/phlex-slotable/blob/main/lib/phlex/slotable.rb) file into your project.
 
-To incorportate slots into your Phlex views, include `Phlex::Slotable` and utilize `slot` class method to define them.
-
-- `slot :slot_name` declaration establishes a single slot intended for rendering once within a view
-- `slot :slot_name, many: true` denotes a slot capable of being rendered multiple times within a view
+Afterward, simply include `Phlex::Slotable` into your Phlex component and utilize `slot` macro to define the component's slots. For example:
 
 ```ruby
-class BlogComponent < Phlex::HTML
+class MyComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header
-  slot :post, many: true
-
-  # ...
+  slot :my_slot
 end
 ```
 
-To render a single slot, utilize the  `{slot_name}_slot` method. For example, you can render the `header_slot` using `render header_slot`.
+Below, you will find a more detailed explanation of how to use the `slot` API.
 
-For multi-slot rendering, iterate over the `{slot_name}_slots` collection and and render each slot individually, eg. `post_slots.each { |s| render s }`.
+## Generic slot
+
+Any content can be passed to components through generic slots, also known as passthrough slots. To define a generic slot, use `slot :{slot_name}`. For example:
 
 ```ruby
-class BlogComponent < Phlex::HTML
+class PageComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header
-  slot :post, many: true
+  slot :title
+end
+```
 
-  def template
-    div id: "header" do
-      render header_slot
-    end
+To render a slot, render the `{slot_name}_slot`:
 
-    div id: "main" do
-      post_slots.each do |slot|
-        p { render slot }
-      end
+```ruby
+class PageComponent < Phlex::HTML
+  include Phlex::Slotable
 
-      span { "Count: #{post_slots.count}" }
-    end
+  slot :title
+
+  def template
+    header { render title_slot }
   end
 end
 ```
 
-When setting slot content, ensure to utilize the  `with_{slot_name}` method while rendering the view:
+To pass content to the component's slot, you should use `with_{slot_name}`:
 
 ```ruby
-class MyPage < Phlex::HTML
-  def template
-    render BlogComponent.new do |blog|
-      blog.with_header do
-        h1 { "Hello World!" }
-      end
-
-      blog.with_post { "Post A" }
-      blog.with_post { "Post B" }
-      blog.with_post { "Post C" }
-    end
+PageComponent.new.call do |page|
+  page.with_title do
+    h1 { "Hello World!" }
   end
 end
-
-MyPage.new.call
 ```
 
-This will output:
+Returning:
 
 ```html
-<div id="header">
-  <h1>Hello World</h1>
-</div>
-<div id="main">
-  <p>Post A</p>
-  <p>Post B</p>
-  <p>Post C</p>
-
-  <span>Count: 3</span>
-</div>
+<header>
+  <h1>Hello World!</h1>
+</header>
 ```
 
-#### Predicate methods
-
-You can verify whether a slot has been provided to the view using `{slot_name}_slot?` for single slots or `{slot_name}_slots?` when for multi-slots.
+You can test if a slot has been passed to the component with `{slot_name}_slot?` method. For example:
 
 ```ruby
-class BlogComponent < Phlex::HTML
+class PageComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header
-  slot :post, many: true
+  slot :title
 
   def template
     if header_slot?
-      div id: "header" do
-        render header_slot
-      end
-    end
-
-    div id: "main" do
-      if post_slots?
-        post_slots.each do |slot|
-          p { render slot }
-        end
-
-        span { "Count: #{post_slots.count}" }
-      else
-        span { "No post yet" }
-      end
+      header { render title_slot }
+    else
+      plain "No title"
     end
   end
 end
 ```
 
-#### View slot
+## Slot collection
 
-Slots have the capability to render other views, Simply pass the view class name to the `slot` method.
+A slot collection denotes a slot capable of being rendered multiple times within a component. It has some minor differences compared to a single slot seen previously. First, you should pass `collection: true` when defining the slot:
 
 ```ruby
-class HeaderComponent < Phlex::HTML
-  def initialize(size:)
-    @size = size
-  end
+class ListComponent < Phlex::HTML
+  include Phlex::Slotable
 
-  def template(&content)
-    h1(class: "text-#{@size}", &content)
-  end
+  slot :item, collection: true
 end
+```
 
-class PostComponent < Phlex::HTML
-  def initialize(featured:)
-    @featured = featured
-  end
-
-  def template(&content)
-    p(class: @featured ? "featured" : nil, &content)
-  end
-end
+To render a collection of slots, iterate over the `{slot_name}_slots` collection and render each slot individually:
 
-class BlogComponent < Phlex::HTML
+```ruby
+class ListComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header, HeaderComponent
-  slot :post, PostComponent, many: true
+  slot :item, collection: true
 
   def template
-    if header_slot?
-      div id: "header" do
-        render header_slot
+    if item_slots?
+      ul do
+        item_slots.each do |item_slot|
+          li { render item_slot }
+        end
       end
     end
 
-    div id: "main" do
-      if post_slots?
-        post_slots.each { render slot }
-
-        span { "Count: #{post_slots.count}" }
-      else
-        span { "No post yet" }
-      end
-    end
+    span { "Total: #{item_slots.size}" }
   end
 end
+```
 
-class MyPage < Phlex::HTML
-  def template
-    render BlogComponent.new do |blog|
-      blog.with_header(size: :lg) { "Hello World!" }
+To set slot content, use the `with_{slot_name}` method when rendering the component. Unlike the single slot,  `with_{slot_name}` can be called multiple times:
 
-      blog.with_post(featured: true) { "Post A" }
-      blog.with_post { "Post B" }
-      blog.with_post { "Post C" }
-    end
-  end
+```ruby
+ListComponent.new.call do |list|
+  list.with_item { "Item A" }
+  list.with_item { "Item B" }
+  list.with_item { "Item C" }
 end
-
-MyPage.new.call
 ```
 
-The output:
+Returning:
 
 ```html
-<div id="header">
-  <h1 class="text-lg">Hello World</h1>
-</div>
-<div id="main">
-  <p class="featured">Post A</p>
-  <p>Post B</p>
-  <p>Post C</p>
+<ul>
+  <li>Item A</li>
+  <li>Item B</li>
+  <li>Item C</li>
+</ul>
 
-  <span>Count: 3</span>
-</div>
+<span>Total: 3</span>
 ```
 
-You can pass the class name as a string for cases where the class isn't evaluated yet, such as with inner classes. For example:
-```ruby
-class BlogComponent < Phlex::HTML
-  include Phlex::Slotable
-
-  # This will not work
-  slot :header, HeaderComponent #  uninitialized constant BlogComponent::HeaderComponent
-  # You should do this
-  slot :header, "HeaderComponent"
+## Component slot
 
-  private
+Slots have the capability to render other components. When defining a slot, provide the name of a component class as the second argument to define a component slot
 
-  class HeaderComponent < Phlex::HTML
-    # ...
-  end
+```ruby
+class ListHeaderComponent < Phlex::HTML
+  # omitted code
 end
-```
 
-#### Lambda slots
-Lambda slots are valuable when you prefer not to create another component for straightforward structures or when you need to render another view with specific parameters
-```ruby
+class ListItemComponent < Phlex::HTML
+  # omitted code
+end
 
-class BlogComponent < Phlex::HTML
+class ListComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header, ->(size:, &content) { render HeaderComponent.new(size: size, color: "blue"), &content }
-  slot :post, ->(featured:, &content) { span(class: featured ? "featured" : nil, &content) }, many: true
-end
+  slot :header, ListHeaderComponent
+  slot :item, ListItemComponent, collection: true
 
-class MyPage < Phlex::HTML
   def template
-    render BlogComponent.new do |blog|
-      blog.with_header(size: :lg) { "Hello World!" }
+    div id: "header" do
+      render header_slot if header_slot?
+    end
 
-      blog.with_post(featured: true) { "Post A" }
-      blog.with_post { "Post B" }
-      blog.with_post { "Post C" }
+    ul do
+      item_slots.each { |slot| render slot }
     end
   end
 end
+
+ListComponent.new.call do |list|
+  list.with_header(size: "lg") { "Hello World!" }
+
+  list.with_item(active: true) { "Item A" }
+  list.with_item { "Item B" }
+  list.with_item { "Item C" }
+end
 ```
 
-You can access the internal view state within lambda slots. For example:
+Returning:
+
+```html
+<div id="header">
+  <h1 class="text-lg">Hello World!</h1>
+
+  <ul>
+    <li class="active">Item A</li>
+    <li>Item B</li>
+    <li>Item C</li>
+  </ul>
+</div>
+```
+
+> [!TIP]
+> You can also pass the component class as a string if your component class hasn't been defined yet. For example:
+>
+> ```ruby
+> slot :header, "HeaderComponent"
+> slot :item, "ItemComponent", collection: true
+>```
+
+
+## Lambda slot
+
+Lambda slots are valuable when you prefer not to create another component for straightforward structures or when you need to render another component with specific parameters.
+
 ```ruby
-class BlogComponent < Phlex::HTML
+class ListComponent < Phlex::HTML
   include Phlex::Slotable
 
-  slot :header, ->(size:, &content) { render HeaderComponent.new(size: size, color: @header_color), &content }
-
-  def initialize(header_color:)
-    @header_color = header_color
+  slot :header, ->(size:, &content) do
+    render HeaderComponent.new(size: size, color: "primary")
   end
-end
+  slot :item, ->(href:, &content) { li { a(href: href, &content) } }, collection: true
 
-class MyPage < Phlex::HTML
   def template
-    render BlogComponent.new(header_color: "red") do |blog|
-      blog.with_header(size: :lg) { "Hello World!" }
+    div id: "header" do
+      render header_slot if header_slot?
+    end
+
+    ul do
+      item_slots.each { |slot| render slot }
     end
   end
 end
+
+ListComponent.new.call do |list|
+  list.with_header(size: "lg") { "Hello World!" }
+
+  list.with_item(href: "/a") { "Item A" }
+  list.with_item(href: "/b") { "Item B" }
+  list.with_item(href: "/c") { "Item C" }
+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.
+Returning:
+
+```html
+<div id="header">
+  <h1 class="text-lg text-primary">Hello World!</h1>
+
+  <ul>
+    <li><a href="/a">Item A</a></li>
+    <li><a href="/b">Item B</a></li>
+    <li><a href="/c">Item C</a></li>
+  </ul>
+</div>
+```
+
+> [!TIP]
+> You can access the internal component state within lambda slots. For example
+>
+> ```ruby
+> slot :header, ->(&content) { render HeaderComponent.new(featured: @featured), &content }
+>
+> def initialize(featured:)
+>   @featured = feature
+> end
+> ```
+
+## Polymorphic slot
+
+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 IconComponent < Phlex::HTML
+  # omitted code
+end
+
+class ImageComponent < Phlex::HTML
+  # omitted code
+end
+
 class CardComponent < Phlex::HTML
   include Phlex::Slotable
 
@@ -285,74 +304,69 @@ class CardComponent < Phlex::HTML
 
   def template
     if avatar_slot?
-      figure id: "avatar" do
+      div 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
+User = Data.define(:image_url)
+user = User.new(image_url: "user.png")
 
-  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
+CardComponent.new.call do |card|
+  if user.image_url
+    card.with_image_avatar(src: user.image_url)
+  else
+    card.with_icon_avatar(name: :user)
   end
 end
 ```
 
-Please note that you can still utilize the other slot definition APIs:
-```ruby
-class CardComponent < Phlex::HTML
-  include Phlex::Slotable
+Returning:
 
-  slot :avatar, types: {
-    icon: IconComponent,
-    image: "ImageComponent",
-    text: ->(size:, &content) { span(class: "text-#{size}", &content) }
-  }, many: true
+```html
+<div id="avatar">
+  <img src="user.png"/>
+</div>
+```
 
-  def template
-    if avatar_slots?
-      avatar_slots.each do |slot|
-        render slot
-      end
-    end
+Note that you need to use `with_{type}_{slot_name}` to set slot content. In the example above, it was used `with_image_avatar` and `with_icon_avatar`.
 
-    span { "Count: #{avatar_slots.size}" }
-  end
+> [!TIP]
+> You can take advantage of all the previously introduced features, such as lambda slot and slot collection:
+>
+> ```ruby
+> slot :avatar, collection: true, types: {
+>   icon: IconComponent,
+>   image: "ImageComponent",
+>   text: ->(&content) { span(class: "avatar", &content) }
+> }
+> ```
 
-  ...
-end
+## Performance
+Using Phlex::Slotable you don't suffer a performance penalty compared to using Phlex::DeferredRender, sometimes it can even be a little faster.
 
-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
+```
+Generated using `ruby benchmark/main.rb`
+
+Phlex 1.11.0
+Phlex::Slotable 0.5.0
+
+ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [arm64-darwin23]
+Warming up --------------------------------------
+            Deferred    22.176k i/100ms
+            Slotable    23.516k i/100ms
+Calculating -------------------------------------
+            Deferred    222.727k (± 0.8%) i/s    (4.49 μs/i) -      1.131M in   5.078157s
+            Slotable    237.405k (± 0.6%) i/s    (4.21 μs/i) -      1.199M in   5.051936s
+
+Comparison:
+            Slotable:   237405.0 i/s
+            Deferred:   222726.8 i/s - 1.07x  slower
 ```
 
 
-## Roadmap
-- ✅ ~~Accept Strings as view class name~~
-- ✅ ~~Allow lambda slots~~
-- ✅ ~~Allow polymorphic slots~~
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -361,7 +375,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/stephannv/phlex-slot. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/stephannv/phlex-slotable/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/stephannv/phlex-slotable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/stephannv/phlex-slotable/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 

data/benchmark/main.rb

@@ -2,6 +2,11 @@ require "benchmark"
 require "benchmark/ips"
 require_relative "../lib/phlex/slotable"
 
+require "phlex/version"
+
+puts "Phlex #{Phlex::VERSION}"
+puts "Phlex::Slotable #{Phlex::Slotable::VERSION}"
+
 class DeferredList < Phlex::HTML
   include Phlex::DeferredRender
 
@@ -9,7 +14,7 @@ class DeferredList < Phlex::HTML
     @items = []
   end
 
-  def template
+  def view_template
     if @header
       h1(class: "header", &@header)
     end
@@ -34,9 +39,9 @@ class SlotableList < Phlex::HTML
   include Phlex::Slotable
 
   slot :header
-  slot :item, many: true
+  slot :item, collection: true
 
-  def template
+  def view_template
     if header_slot
       h1(class: "header", &header_slot)
     end
@@ -50,7 +55,7 @@ class SlotableList < Phlex::HTML
 end
 
 class DeferredListExample < Phlex::HTML
-  def template
+  def view_template
     render DeferredList.new do |list|
       list.header do
         "Header"
@@ -68,7 +73,7 @@ class DeferredListExample < Phlex::HTML
 end
 
 class SlotableListExample < Phlex::HTML
-  def template
+  def view_template
     render SlotableList.new do |list|
       list.with_header do
         "Header"

data/lib/phlex/slotable/version.rb

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

data/lib/phlex/slotable.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "phlex"
+require_relative "slotable/version"
 
 module Phlex
   module Slotable
@@ -9,41 +10,42 @@ module Phlex
     end
 
     module ClassMethods
-      def slot(slot_name, callable = nil, types: nil, many: false)
+      def slot(slot_name, callable = nil, types: nil, collection: false)
         include Phlex::DeferredRender
 
         if types
           types.each do |type, callable|
-            define_setter_method(slot_name, callable, many: many, type: type)
+            define_setter_method(slot_name, callable, collection: collection, type: type)
           end
         else
-          define_setter_method(slot_name, callable, many: many)
+          define_setter_method(slot_name, callable, collection: collection)
         end
-        define_predicate_method(slot_name, many: many)
-        define_getter_method(slot_name, many: many)
+        define_predicate_method(slot_name, collection: collection)
+        define_getter_method(slot_name, collection: collection)
       end
 
       private
 
-      def define_setter_method(slot_name, callable, many:, type: nil)
+      def define_setter_method(slot_name, callable, collection:, type: nil)
         slot_name_with_type = type ? "#{type}_#{slot_name}" : slot_name
+        signature = callable.nil? ? "(&block)" : "(*args, **kwargs, &block)"
 
-        setter_method = if many
+        setter_method = if collection
           <<-RUBY
-            def with_#{slot_name_with_type}(*args, **kwargs, &block)
+            def with_#{slot_name_with_type}#{signature}
               @#{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)
+            def with_#{slot_name_with_type}#{signature}
               @#{slot_name}_slot = #{callable_value(slot_name_with_type, callable)}
             end
           RUBY
         end
 
-        class_eval(setter_method, __FILE__, __LINE__ + 1)
+        class_eval(setter_method, __FILE__, __LINE__)
         define_lambda_method(slot_name_with_type, callable) if callable.is_a?(Proc)
       end
 
@@ -52,44 +54,40 @@ module Phlex
         private :"__call_#{slot_name}__"
       end
 
-      def define_getter_method(slot_name, many:)
-        getter_method = if many
+      def define_getter_method(slot_name, collection:)
+        getter_method = if collection
           <<-RUBY
-            def #{slot_name}_slots
-              @#{slot_name}_slots ||= []
-            end
+            def #{slot_name}_slots = @#{slot_name}_slots ||= []
+
             private :#{slot_name}_slots
           RUBY
         else
           <<-RUBY
-            def #{slot_name}_slot
-              @#{slot_name}_slot
-            end
+            def #{slot_name}_slot = @#{slot_name}_slot
+
             private :#{slot_name}_slot
           RUBY
         end
 
-        class_eval(getter_method, __FILE__, __LINE__ + 1)
+        class_eval(getter_method, __FILE__, __LINE__)
       end
 
-      def define_predicate_method(slot_name, many:)
-        predicate_method = if many
+      def define_predicate_method(slot_name, collection:)
+        predicate_method = if collection
           <<-RUBY
-            def #{slot_name}_slots?
-              #{slot_name}_slots.any?
-            end
+            def #{slot_name}_slots? = #{slot_name}_slots.any?
+
             private :#{slot_name}_slots?
           RUBY
         else
           <<-RUBY
-            def #{slot_name}_slot?
-              !#{slot_name}_slot.nil?
-            end
+            def #{slot_name}_slot? = !#{slot_name}_slot.nil?
+
             private :#{slot_name}_slot?
           RUBY
         end
 
-        class_eval(predicate_method, __FILE__, __LINE__ + 1)
+        class_eval(predicate_method, __FILE__, __LINE__)
       end
 
       def callable_value(slot_name, callable)
@@ -97,7 +95,7 @@ module Phlex
         when nil
           %(block)
         when Proc
-          %(-> { self.class.instance_method(:"__call_#{slot_name}__").bind_call(self, *args, **kwargs, &block) })
+          %(-> { __call_#{slot_name}__(*args, **kwargs, &block) })
         else
           %(#{callable}.new(*args, **kwargs, &block))
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phlex-slotable
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - stephann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-14 00:00:00.000000000 Z
+date: 2024-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 description:
 email:
 - 3025661+stephannv@users.noreply.github.com
@@ -53,14 +59,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
 summary: Enable Slot API for Phlex views