slotify 0.0.1.alpha.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b774ed1d3d704f77cbeebc55d117488eb70f52c1a00527dda727d6cb9100d72
-  data.tar.gz: b8c6ce6b033715c768315671e6d3547925943825a100f5ea67e11d7df7b81ba6
+  metadata.gz: c0623930b397a09cafd4f47da222d46595e013da9987ee1491be5c501689e095
+  data.tar.gz: 29f4f8d8427932b1bf85ed6205262e2dbe8196281951bec74042b2f35967928c
 SHA512:
-  metadata.gz: ad4a579d74c471684a40b0d60cd8362325cb529d13a362c73d23f5aa67f7383d8d4c9853ebe3e9e4120a31126c4a0069688c924a38ceb8ae0d857e0ba3935b59
-  data.tar.gz: c64f9c44d9880d0488acac9bcc0a4882780b1517024ac86c3b73177f287817bf70ea52d036b74516c0e3f7a4681453acdfccda46b1d9b98ca80f011a09857ebf
+  metadata.gz: b14613a0d5522daf91565b60860c24df657a67807751034aab3a91d70888edeb0bcf381120e958fd42d9cf04290cc7b65964b913ea6a66339d6e375922109608
+  data.tar.gz: 754d99784a31195603eaa9a4c9e91dc4cf4575e7987f181163ff6062251cfe50c7af5ff75f2133f552d7b57aaedc327e43c5d0fe74253964528503ea7fa54404

data/README.md

@@ -1,36 +1,39 @@
 <img src=".github/assets/slotify_wordmark.svg" width="200">
 
-#### Superpowered slots for ActionView partials
+<p><a href="https://rubygems.org/gems/slotify"><img src="https://img.shields.io/gem/v/slotify" alt="Gem version"></a>
+<a href="https://github.com/allmarkedup/slotify/actions/workflows/ci.yml"><img src="https://github.com/allmarkedup/slotify/actions/workflows/ci.yml/badge.svg" alt="CI status"></a></p>
 
-----------
+## Superpowered slots for ActionView partials
 
-## Overview 
-
-Slotify adds an unobtrusive but powerful **content slot API** to ActionView partials.
+Slotify adds an unobtrusive (but powerful!) **content slot API** to ActionView partials. 
 
 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.
 
-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/).
+Slotified partials are a great way to build components in a Rails app without the additional overhead and learning curve of libraries like [ViewComponent](https://viewcomponent.org/) or [Phlex](https://www.phlex.fun/).
+
+> [!CAUTION]
+> Slotify is still in a early stage of development.
+The documentation is still quite sparse and the API could change at any point prior to a `v1.0` release.
 
 ### 
 
 ## Slotify basics
 
-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)).
+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)).
 
 ```erb
-<%# slots: (slot_name: "default value", optional_slot_name: nil, required_slot_name:) -%>
+<%# slots: (title:, body: nil, theme: "default") -%>
 ```
 
-Slot content is accessed via standard local variables within the partial. So a simple slot-enabled `article` partial template might look something like this:
+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
 <!-- _article.html.erb -->
 
-<%# slots: (heading: "Default title", body: nil) -%>
+<%# slots: (title: "Default title", body: nil) -%>
 
 <article>
-  <h1><%= heading %></h1>
+  <h1><%= title %></h1>
   <% if body.present? %>
     <div>
       <%= body %>
@@ -40,17 +43,15 @@ Slot content is accessed via standard local variables within the partial. So a s
 ```
 
 > [!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!)._
+> _The above should feel familiar to anyone who has partials (and strict locals) 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!)._
 
-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.
+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:
+For example, here our `article` partial is being rendered with content for the `title` and `body` slots that were defined above:
 
 ```erb
-<!-- index.html.erb -->
-
 <%= render "article" do |partial| %>
-  <% partial.with_heading "This is a title" %>
+  <% partial.with_title "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>
@@ -61,82 +62,10 @@ For example, here our `article` partial is being rendered with content for the `
 > [!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)._
 
-The example above just scratches the surface of what Slotify slots can do.
-
-You can [jump to a more full-featured example here](#full-example) or read on to learn more...
-
-## Single vs multiple value slots
-
-> _Docs coming soon..._ 
-
-## Slot arguments and options
-
-> _Docs coming soon..._ 
-
-## Using helpers with slots
-
-> _Docs coming soon..._ 
-
-## Rendering slot contents
-
-> _Docs coming soon..._ 
-
-<a name="defining-slots" id="defining-slots"></a>
-## Defining slots
+But this example just scratches the surface of what Slotify slots can do. Have a look at the more full-featured example below or jump to [the usage information](#usage).
 
-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"
-```
-
-And then run `bundle install`. You are good to go!
-
-## 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
+<details>
+<summary><h4>More full-featured example</h4></summary>
 
 ```erb
 <!-- views/_example.html.erb -->
@@ -149,7 +78,7 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
     <%= title %>
   </h1>
   
-  <p>Example link: <%= partial.link_to website_link, data: {controller: "external-link"} %></p>
+  <p>Example link: <%= link_to website_link, data: {controller: "external-link"} %></p>
 
   <%= render lists, title: "Default title" %>
 
@@ -175,7 +104,7 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
 
 <% if items.any? %>
   <%= tag.ul class: "list" do %>
-    <%= partial.li items, class: "list-item" %>
+    <%= content_tag :li, items, class: "list-item" %>
   <% end %>
 <% end %>
 ```
@@ -206,4 +135,427 @@ Slotify was inspired by the excellent [nice_partials gem](https://github.com/bul
 <% end %>
 ```
 
+</details>
+
+---
+
+## Usage
+
+<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:
+
+```erb
+<%# slots: (title:, body: "No content available", author: nil) -%>
+```
+
+#### Required slots
+
+Required slots are defined without a default value.
+If no content is provided for a required slot then a `StrictSlotsError` exception will be raised.
+
+```erb
+<!-- _required.html.erb -->
+
+<%# slots: (title:) -%>
+<h1><%= title %></h1>
+```
+
+```erb
+<%= render "required" do |partial| %>  
+  <!-- ❌ raises an error, no content set for the `title` slot -->
+<% end %>
+```
+
+#### Optional slots
+
+If a default value is set then the slot becomes _optional_. If no content is provided when rendering the partial then
+the default value will be used instead.
+
+```erb
+<%# slots: (title: "Default title", author: nil) -%>
+```
+
+### Using alongside strict locals
+
+Strict locals can be defined in 'slotified' partial templates in the same way as usual,
+either above or below the `slots` definition.
+
+```erb
+<!-- _article.html.erb -->
+
+<%# locals: (title:) -%>
+<%# slots: (body: "No content available") -%>
+
+<article>
+  <h1><%= title %></h1>
+  <div><%= body %></div>
+</article>
+```
+
+Locals are provided when rendering the partial in the usual way.
+
+```erb
+<%= render "article", title: "Article title here" do |partial| %>
+  <% partial.with_body do %>
+    <p>Body content here...</p>
+  <% end %>
+<% end %>
+```
+
+### Setting slot values
+
+Content is passed into slots using dynamically generated `partial#with_<slot_name>` writer methods.
+
+Content can be provided as either the **first argument** or **as a block** when calling these methods at render time.
+The following two examples are equivalent:
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_title "Title passed as argument" %>
+<% end %>
+```
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_title do %>
+    Title passed as block content
+  <% end %>
+<% end %>
+```
+
+> [!TIP]
+> Block content is generally better suited for longer-form content containing HTML tags because it will not need to be marked
+as `html_safe` when used in the partial template.
+
+The content will be available as a local variable in the partial template whichever way it is provided.
+
+```erb
+<%# slots: (title:) -%>
+<h1><%= title %></h1> 
+```
+
+### Slot options
+
+The slot value writer methods also accept optional arbitrary keyword arguments.
+These can then be accessed in the partial template via the `.options` method on the slot variable.
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_title "The title", class: "color-hotpink", data: {controller: "fancy-title"} %>
+<% end %>
+```
+
+```erb
+<%# slots: (title:) -%>
+
+<%= title.options.keys %> <!-- [:class, :data] -->
+<%= title %> <!-- The title -->
+```
+
+Slot options can be useful for providing tag attributes when rendering slot content or rendering variants
+of a slot based on an option value.
+
+When rendered as a string the options are passed through the Rails `tag.attributes` helper to generate an HTML tag attributes string:
+
+```erb
+<h1 <%= title.options %>><%= title %></h1> 
+<!-- <h1 class="color-hotpink" data-controller="fancy-title">The title</h1> -->
+```
+
+### Slot types
+
+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**.
+
+#### Single-value slots
+
+Single-value slots are defined using a **singlular** slot name:
+
+```erb
+<%# slots: (item: nil) -%>
+```
+
+Single-value slots can be called once (at most)
+and their corresponding template variable represents a single value:
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+<% end %>
+```
+
+```erb
+<%# slots: (item: nil) -%>
+<div>
+  <%= item %> <!-- "Item one" -->
+</div>
+```
+
+> [!WARNING]
+> Calling a single-value slot more than once when rendering a partial will raise an error:
+> 
+> ```erb
+> <%= render "example" do |partial| %>
+>   <% partial.with_item "Item one" %>
+>   <% partial.with_item "Item two" %> # ❌ raises an error!
+> <% end %>
+> ```
+
+#### Multiple-value slots
+
+Multiple-value slots are defined using a **plural** slot name:
+
+```erb
+<%# slots: (items: nil) -%>
+```
+
+Multiple-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).
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+  <% partial.with_item "Item two" %>
+  <% partial.with_item "Item three" %>
+<% end %>
+```
+
+```erb
+<%# slots: (items: nil) -%>
+
+<%= items %> <!-- ["Item one", "Item two", "Item three"] -->
+
+<ul>
+  <% items.each do |item| %>
+    <li>
+      <% item %>
+    </li>
+  <% end %>
+</ul>
+```
+
+### Using slots with helpers
+
+> _Docs coming soon..._ 
+
+```erb
+<% partial.with_title "The title", class: "color-hotpink" %>
+<% partial.with_website_link "Example website", "https://example.com", data: {controller: "external-link"} %>
+
+<% partial.with_item "Item one" %>
+<% partial.with_item "Item two", class: "highlight" %>
+```
+
+```erb
+<%= content_tag :h1, title %> <!-- <h1 class="color-hotpink">The title</h1> -->
+<%= content_tag :h1, title, class: "example-title" %> <!-- <h1 class="example-title color-hotpink">The title</h1> -->
+
+<%= link_to website_link %> <!-- <a href="https://example.com" data-controller="external-link">Example website</a> -->
+
+<%= content_tag :li, items %> <!-- <li>Item one</li><li class="highlight">Item two</li> -->
+<%= content_tag :li, items, class: "item" %> <!-- <li class="item">Item one</li><li class="item highlight">Item two</li> -->
+```
+
+### Rendering slots
+
+> _Docs coming soon..._ 
+
+### Slot values API
+
+**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 %>
+    The title
+  <% end %>
+<% end %>
+```
+
+```erb
+<% title.is_a?(Slotify::Value) %> <!-- true -->
+<% items.is_a?(Slotify::ValueCollection) %> <!-- true -->
+
+<%= title %> <!-- "The title" -->
+<% title.content %> <!-- "The title" -->
+
+<% title.options %> <!-- { class: "color-hotpink" } (hash of any options provided when calling the `.with_title` slot value writer method) -->
+<%= title.options %> <!-- "class='color-hotpink'" (string generated by passing the options hash through the Rails `tag.attributes` helper) -->
+```
+
+**Plural slot value variables** in partial templates are instances of the enumerable `Slotify::ValueCollection` class, with all items instances of `Slotity::Value`.
+
+```erb
+<%= render "example" do |partial| %>
+  <% partial.with_item "Item one" %>
+  <% partial.with_item "Item two", class: "current" %>
+<% end %>
+```
+
+```erb
+<% items.is_a?(Slotify::ValueCollection) %> <!-- true -->
 
+<% items.each do |item| %>
+  <li <%= item.options %>><%= item %></li>
+<% end %>
+<!-- <li>Item one</li> <li class="current">Item two</li> -->
+
+<%= items %> <!-- "Item one Item two" -->
+```
+
+#### `Slotity::Value`
+
+The following methods are available on `Slotity::Value` instances:
+
+**`.content`**
+
+Returns the slot content string that was provided as the first argument or as the block when calling the slot writer method.
+
+**`.options`**
+
+Returns a `Slotify::ValueOptions` instance that can be treated like a `Hash`. Calling `.slice` or `.except` on this will return another `Slotify::ValueOptions` instance.
+
+When converted to a string either explicitly (via `.to_s`) or implicitly (by outputting the value template using ERB `<%= %>` expression tags) the stringified value is generated by passing the options hash through the Rails `tag.attributes` helper.
+
+**`.with_default_options(default_options)`**
+
+Merges the options set when calling the slot value writer method with the `default_options` hash provided and returns a new `Slotity::Value` instance with the merged options set.
+
+```erb
+<% title_with_default_opts = title.with_default_options(class: "size-lg", aria: {level: 1}) %> <!-- apply default options -->
+
+<% title_with_default_opts.options %> <!-- { class: "size-lg color-hotpink", aria: {level: 1} } -->
+<%= title_with_default_opts.options %> <!-- "class='size-lg color-hotpink' aria-level='1'" -->
+```
+
+## Slotify vs alternatives
+
+#### `nice_partials`
+
+Slotify was very much inspired by the [Nice Partials gem](https://github.com/bullet-train-co/nice_partials) and both provide similar functionality.
+However there are a number of key differences:
+
+* Slotify requires the explicit definition of slots using 'strict locals'-style comments;
+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 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
+
+You might choose slotify if you prefer a stricter, 'Rails-native'-feeling slots implementation, and Nice Partials if you want more render-time flexibility and a clearer
+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
+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.
+
+Each ViewComponent has an associated class which can be used to extract and encapsulate view logic.
+Slotify doesn't have an analagous concept, any view-specific logic will by default live in the partial template (as per standard partial rendering patterns). 
+
+You might choose Slotify if you want a more 'component-y' API but you don't want the overhead or learning curve associated with a tool that sits somewhat adjacent to the standard Rails way of doing things.
+But if you have components with a lot of view logic or want a more formalised component format then ViewComponent is likely a better fit for your project.
+
+## Installation
+
+Add the following to your Rails app Gemfile:
+
+```rb
+gem "slotify"
+```
+
+And then run `bundle install`. You are good to go!
+
+## 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)!
+
+## Benchmarks
+
+Slotify is still in the early stages of development and no attempt has yet been made to optimise rendering performance.
+
+Below are some initial (crude) benchmarking comparisons with other similar gems.
+
+> [!TIP]
+> Benchmarks can be run using the `bin/benchmarks` command from the repository root.
+
+```
+✨🦄 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
+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
+
+Comparison:
+            no slots:   125621.9 i/s
+               slots:   108467.5 i/s - 1.16x  slower
+
+
+✨🦄 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
+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
+
+Comparison:
+            no slots:   114190.2 i/s
+               slots:    41137.9 i/s - 2.78x  slower
+
+
+✨🦄 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
+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
+
+Comparison:
+            no slots:   196287.6 i/s
+               slots:    71310.5 i/s - 2.75x  slower
+
+
+✨🦄 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
+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
+
+Comparison:
+            no slots:   110152.8 i/s
+               slots:      789.1 i/s - 139.59x  slower
+```

data/lib/slotify/concerns/inflection_helper.rb

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

data/lib/slotify/concerns/slot_compatability.rb

@@ -0,0 +1,20 @@
+module Slotify
+  module SlotCompatability
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def make_compatible_with_slots(*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 = MethodArgsResolver.call(args, kwargs, block) { super(*_1, **_2, &_3) }
+            results.reduce(ActiveSupport::SafeBuffer.new) { _1 << _2 }
+          end
+        end
+        prepend proxy
+      end
+    end
+  end
+end

data/lib/slotify/error.rb

@@ -2,16 +2,13 @@ module Slotify
   class UnknownSlotError < NameError
   end
 
-  class MissingRequiredSlotError < ArgumentError
+  class SlotsDefinedError < RuntimeError
   end
 
-  class MultipleSlotEntriesError < ArgumentError
-  end
-
-  class SlotsAccessError < RuntimeError
+  class UndefinedSlotError < StandardError
   end
 
-  class UndefinedSlotError < StandardError
+  class MultipleSlotEntriesError < ArgumentError
   end
 
   class SlotArgumentError < ArgumentError
@@ -19,4 +16,7 @@ module Slotify
 
   class StrictSlotsError < ArgumentError
   end
+
+  class ReservedSlotNameError < ArgumentError
+  end
 end