active_interaction 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 557de518b6e1a33937d70d31e6c29dd6179384372e082595f8087b3efcdae784
-  data.tar.gz: 2ba312b6ddc61043acbc8bcb48dbbc4a60010be6701a5a368325d0a14fc4c557
+  metadata.gz: 0cfed756a5463384a07d694ba40f14067dce231d2618af2f16e6fd429e31b97f
+  data.tar.gz: eb3b185d234762dec1799fbaa6e8acf290a47e0940b24c3da529f11172e6fde5
 SHA512:
-  metadata.gz: 28674a0400c7bd8dafaae7430f1609fdbd3cd93e3ca5c60a07d2df2970b825a7e218d2482026f0a6365ba11fdd6518830fdfb96f496909ee7d8cb63154c5b8e7
-  data.tar.gz: e527210922d3e9af79ff3c61f2e5d1ba873fe9eb31be543ffd640d255f69de19b40d0621ff9900db19e3cf3f553c8cfbcf583954385d2c8a3db2f24a747037f7
+  metadata.gz: b2ce2d6ef28bc84e2cc614dd9e6dde57c14a92efcafe706e8cb532b1c0fa9c192db8548771b94198236f3ab3ec6baa9633c2625c3f8b73cbcc1291752078be6c
+  data.tar.gz: 3f5f3c15059c19c7fec77256a260fc67f98444ab5dba48048f2797a441a348f7deea31b7b558e0b1af334ffd8a6e1685756745ecebdc87ee658dafc42f8043c4

data/CHANGELOG.md

@@ -1,3 +1,128 @@
+# [5.0.0][] (2022-06-24)
+
+## Changed
+
+- Drop support for JRuby.
+- Drop support for Ruby 2.5 and 2.6, adding support for 3.1
+- Drop support for Rails 5.0 and 5.1
+- `ActiveInteraction::Inputs` no longer inherits from `Hash` though it still has most of the methods
+  provided by `Hash` (methods that write were removed).
+- Removed `Filter#clean` (use `Filter#process` and call `#value` on the result)
+- The `given?` method has been moved onto `inputs`. ([how to upgrade](#given))
+- [#503][] - The record filter now treats blank strings value as `nil`. This was missed in the 4.0 update.
+- The `type_check` callback has been renamed to `filter` to better match the reality of what it does.
+  ([how to upgrade](#filter-callback))
+- `ActiveIneraction::FilterColumn` is now `ActiveInteraction::Filter::Column`
+- Errors on the array filter will now be indexed if the Rails config `index_nested_attribute_errors`
+  is `true` or the `:index_errors` option is set to `true`. The `:index_errors` option always overrides
+  the Rails config.
+- Invalid nested errors (`:invalid_nested`) are gone. Instead the nested errors will appear as they would
+  in Rails if they were a `has_many` relationship being assigned attributes through a parent.
+  ([how to upgrade](#nested-hash-errors))
+
+## Added
+
+- `Filter#process` which returns an `Input`.
+
+## Fixed
+
+- When passing an `ActiveRecord::Relation` in an array filter with no inner
+  filter, the value returned was an `ActiveRecord::Relation` instead of an
+  Array.
+
+## Upgrading
+
+### `given?`
+
+The `given?` method can now be found on `inputs`. It works the same as before.
+
+```ruby
+# 4.1
+class Example < ActiveInteraction::Base
+  string :name, default: nil
+
+  def execute
+    given?(:name)
+  end
+end
+
+# 5.0
+class Example < ActiveInteraction::Base
+  string :name, default: nil
+
+  def execute
+    inputs.given?(:name)
+  end
+end
+```
+
+### Filter Callback
+
+You'll need to rename any `:type_check` callbacks to `:filter`.
+
+```ruby
+# 4.1
+set_callback :type_check, :before, -> { puts 'before type check' }
+
+# 5.0
+set_callback :filter, :before, -> { puts 'before type check' }
+```
+
+### Nested Hash Errors
+
+Nested hash errors no longer add an error as through it happened on the hash.
+They now use the error in its original form and attach the name of the hash to
+the error. It is also not limited to returning one error.
+
+```ruby
+class HashInteraction < ActiveInteraction::Base
+  hash :mailing_lists do
+    boolean :marketing
+    boolean :product_updates
+  end
+
+  def execute
+    # ...
+  end
+end
+
+> outcome = HashInteraction.run(mailing_lists: {})
+
+# 4.1
+> outcome.errors.details
+# => {:mailing_lists=>[{:error=>:invalid_nested, :name=>"\"marketing\"", :value=>"nil"}]},
+> outcome.errors.messages
+# => {:mailing_lists=>["has an invalid nested value (\"marketing\" => nil)"]}
+> outcome.errors.full_messages
+# => ["Mailing lists has an invalid nested value (\"marketing\" => nil)"]
+
+# 5.0
+> outcome.errors.details
+# => {:"mailing_lists.marketing"=>[{:error=>:missing}], :"mailing_lists.product_updates"=>[{:error=>:missing}]}
+> outcome.errors.messages
+# => {:"mailing_lists.marketing"=>["is required"], :"mailing_lists.product_updates"=>["is required"]}
+> outcome.errors.full_messages
+# => ["Mailing lists marketing is required", "Mailing lists product updates is required"]
+```
+
+I18n can handle these values the same as nested values in Rails:
+
+```yml
+en:
+  active_interaction:
+    attributes:
+      hash_interaction/mailing_lists:
+        marketing: 'Mailing list "Marketing"'
+        product_updates: 'Mailing list "Product Updates"'
+```
+
+Using the same example from above:
+
+```ruby
+> outcome.errors.full_messages
+# => ["Mailing list \"Marketing\" is required", "Mailing list \"Product Updates\" is required"]
+```
+
 # [4.1.0][] (2021-12-30)
 
 ## Added
@@ -68,7 +193,7 @@
 
 ## Added
 
-- Implicit coercion of types are now supported in filters (e.g. to_str, to_int,
+- Implicit coercion of types are now supported in filters (e.g. `to_str`, `to_int`,
   etc).
 - The `interface` and `record` filters, when used as an inner filter for an
   `array`, will have their `from/class` option set to a singularized version of
@@ -976,6 +1101,7 @@ Example.run
 
 - Initial release.
 
+  [5.0.0]: https://github.com/AaronLasseigne/active_interaction/compare/v4.1.0...v5.0.0
   [4.1.0]: https://github.com/AaronLasseigne/active_interaction/compare/v4.0.6...v4.1.0
   [4.0.6]: https://github.com/AaronLasseigne/active_interaction/compare/v4.0.5...v4.0.6
   [4.0.5]: https://github.com/AaronLasseigne/active_interaction/compare/v4.0.4...v4.0.5
@@ -1198,3 +1324,4 @@ Example.run
   [#480]: https://github.com/AaronLasseigne/active_interaction/issues/480
   [#515]: https://github.com/AaronLasseigne/active_interaction/issues/515
   [#518]: https://github.com/AaronLasseigne/active_interaction/issues/518
+  [#503]: https://github.com/AaronLasseigne/active_interaction/issues/503

data/README.md

@@ -1,7 +1,7 @@
 # [ActiveInteraction][]
 
 ActiveInteraction manages application-specific business logic.
-It's an implementation of the command pattern in Ruby.
+It's an implementation of service objects designed to blend seamlessly into Rails.
 
 [![Version](https://img.shields.io/gem/v/active_interaction.svg?style=flat-square)](https://rubygems.org/gems/active_interaction)
 [![Test](https://img.shields.io/github/workflow/status/AaronLasseigne/active_interaction/Test?label=Test&style=flat-square)](https://github.com/AaronLasseigne/active_interaction/actions?query=workflow%3ATest)
@@ -51,7 +51,7 @@ handles your verbs.
   - [Descriptions](#descriptions)
   - [Errors](#errors)
   - [Forms](#forms)
-  - [Grouped inputs](#grouped-inputs)
+  - [Shared input options](#shared-input-options)
   - [Optional inputs](#optional-inputs)
   - [Translations](#translations)
 - [Credits](#credits)
@@ -63,18 +63,17 @@ handles your verbs.
 Add it to your Gemfile:
 
 ``` rb
-gem 'active_interaction', '~> 4.1'
+gem 'active_interaction', '~> 5.0'
 ```
 
 Or install it manually:
 
 ``` sh
-$ gem install active_interaction --version '~> 4.1'
+$ gem install active_interaction --version '~> 5.0'
 ```
 
 This project uses [Semantic Versioning][]. Check out [GitHub releases][] for a
-detailed list of changes. For help upgrading to version 2, please read [the
-announcement post][].
+detailed list of changes.
 
 ## Basic usage
 
@@ -89,7 +88,7 @@ you need to do two things:
 2.  **Define your business logic.** Do this by implementing the `#execute`
     method. Each input you defined will be available as the type you specified.
     If any of the inputs are invalid, `#execute` won't be run. Filters are
-    responsible for type checking your inputs. Check out [the validations
+    responsible for checking your inputs. Check out [the validations
     section](#validations) if you need more than that.
 
 That covers the basics. Let's put it all together into a simple example that
@@ -141,7 +140,7 @@ Square.run!(x: 2.1)
 
 ### Validations
 
-ActiveInteraction type checks your inputs. Often you'll want more than that.
+ActiveInteraction checks your inputs. Often you'll want more than that.
 For instance, you may want an input to be a string with at least one
 non-whitespace character. Instead of writing your own validation for that, you
 can use validations from ActiveModel.
@@ -164,7 +163,7 @@ end
 ```
 
 When you run this interaction, two things will happen. **First
-ActiveInteraction will type check your inputs. Then ActiveModel will validate
+ActiveInteraction will check your inputs. Then ActiveModel will validate
 them.** If both of those are happy, it will be executed.
 
 ``` rb
@@ -261,6 +260,32 @@ array :managers do
 end
 ```
 
+Errors that occur will be indexed based on the Rails configuration setting
+`index_nested_attribute_errors`. You can also manually override this setting
+with the `:index_errors` option. In this state is is possible to get multiple
+errors from a single filter.
+
+```ruby
+class ArrayInteraction < ActiveInteraction::Base
+  array :favorite_numbers, index_errors: true do
+    integer
+  end
+
+  def execute
+    favorite_numbers
+  end
+end
+
+ArrayInteraction.run(favorite_numbers: [8, 'bazillion']).errors.details
+=> {:"favorite_numbers[1]"=>[{:error=>:invalid_type, :type=>"array"}]}
+```
+
+With `:index_errors` set to `false` the error would have been:
+
+```ruby
+{:favorite_numbers=>[{:error=>:invalid_type, :type=>"array"}]}
+```
+
 ### Boolean
 
 Boolean filters convert the strings `"1"`, `"true"`, and `"on"`
@@ -464,8 +489,8 @@ not an instance of the class or one of its subclasses. The `converter` option
 accepts a symbol that specifies a class method on the object class or a proc.
 Both will be passed the value and any errors thrown inside the converter will
 cause the value to be considered invalid. Any returned value that is not the
-correct class will also be treated as invalid. The value given to the `default`
-option will also be converted.
+correct class will also be treated as invalid. Any `default` that is not an
+instance of the class or subclass and is not `nil` will also be converted.
 
 ``` rb
 class ObjectInteraction < ActiveInteraction::Base
@@ -492,8 +517,9 @@ of its subclasses) or a value that can be used to locate an instance of the
 object. If the value does not match, it will call `find` on the class of the
 record. This is particularly useful when working with ActiveRecord objects.
 Like an object filter, the class is derived from the name passed but can be
-specified with the `class` option. The value given to the `default` option will
-also be found.
+specified with the `class` option. Any `default` that is not an instance of the
+class or subclass and is not `nil` will also be found. Blank strings passed in
+will be treated as `nil`.
 
 ``` rb
 class RecordInteraction < ActiveInteraction::Base
@@ -736,10 +762,7 @@ resourceful actions.
 
 We recommend putting your interactions in `app/interactions`. It's also very
 helpful to group them by model. That way you can look in
-`app/interactions/accounts` for all the ways you can interact with accounts. In
-order to use this structure add
-`config.autoload_paths += Dir.glob("#{config.root}/app/interactions/*")` in
-your `application.rb`
+`app/interactions/accounts` for all the ways you can interact with accounts.
 
 ```
 - app/
@@ -842,7 +865,7 @@ end
 ```
 
 Note that it's perfectly fine to add errors during execution. Not all errors
-have to come from type checking or validation.
+have to come from checking or validation.
 
 #### New
 
@@ -1025,7 +1048,7 @@ interaction's lifecycle.
 
 ``` rb
 class Increment < ActiveInteraction::Base
-  set_callback :type_check, :before, -> { puts 'before type check' }
+  set_callback :filter, :before, -> { puts 'before filter' }
 
   integer :x
 
@@ -1047,7 +1070,7 @@ class Increment < ActiveInteraction::Base
 end
 
 Increment.run!(x: 1)
-# before type check
+# before filter
 # after validate
 # >>>
 # executing
@@ -1055,7 +1078,7 @@ Increment.run!(x: 1)
 # => 2
 ```
 
-In order, the available callbacks are `type_check`, `validate`, and `execute`.
+In order, the available callbacks are `filter`, `validate`, and `execute`.
 You can set `before`, `after`, or `around` on any of them.
 
 ### Composition
@@ -1178,7 +1201,7 @@ errors.
 ``` rb
 outcome = BuyItem.run(item: 'Thing', options: { gift_wrapped: 'yes' })
 outcome.errors.messages
-# => {:credit_card=>["is required"], :item=>["is not a valid object"], :options=>["has an invalid nested value (\"gift_wrapped\" => \"yes\")"]}
+# => {:credit_card=>["is required"], :item=>["is not a valid object"], :"options.gift_wrapped"=>["is not a valid boolean"]}
 ```
 
 Determining the type of error based on the string is difficult if not
@@ -1187,7 +1210,7 @@ the same list of errors with a testable label representing the error.
 
 ``` rb
 outcome.errors.details
-# => {:credit_card=>[{:error=>:missing}], :item=>[{:type=>"object", :error=>:invalid_type}], :options=>[{:name=>"\"gift_wrapped\"", :value=>"\"yes\"", :error=>:invalid_nested}]}
+# => {:credit_card=>[{:error=>:missing}], :item=>[{:error=>:invalid_type, :type=>"object"}], :"options.gift_wrapped"=>[{:error=>:invalid_type, :type=>"boolean"}]}
 ```
 
 Detailed errors can also be manually added during the execute call by passing a
@@ -1337,7 +1360,7 @@ used to define the inputs on your interaction will relay type information to
 these gems. As a result, form fields will automatically use the appropriate
 input type.
 
-### Grouped inputs
+### Shared input options
 
 It can be convenient to apply the same options to a bunch of inputs. One common
 use case is making many inputs optional. Instead of setting `default: nil` on
@@ -1358,8 +1381,8 @@ Optional inputs can be defined by using the `:default` option as described in
 are merged to create `inputs`. There are times where it is useful to know
 whether a value was passed to `run` or the result of a filter default. In
 particular, it is useful when `nil` is an acceptable value. For example, you
-may optionally track your users' birthdays. You can use the `given?` predicate
-to see if an input was even passed to `run`. With `given?` you can also check
+may optionally track your users' birthdays. You can use the `inputs.given?` predicate
+to see if an input was even passed to `run`. With `inputs.given?` you can also check
 the input of a hash or array filter by passing a series of keys or indexes to
 check.
 
@@ -1370,7 +1393,7 @@ class UpdateUser < ActiveInteraction::Base
     default: nil
 
   def execute
-    user.birthday = birthday if given?(:birthday)
+    user.birthday = birthday if inputs.given?(:birthday)
     errors.merge!(user.errors) unless user.save
     user
   end
@@ -1424,7 +1447,6 @@ hsilgne:
     errors:
       messages:
         invalid: dilavni si
-        invalid_nested: (%{value} <= %{name}) eulav detsen dilavni na sah
         invalid_type: '%{type} dilav a ton si'
         missing: deriuqer si
 ```
@@ -1444,6 +1466,19 @@ I18nInteraction.run(name: false).errors.messages[:name]
 # => ["gnirts dilav a ton si"]
 ```
 
+Everything else works like an `activerecord` entry. For example, to rename an
+attribute you can use `attributes`.
+
+Here we'll rename the `num` attribute on an interaction named `product`:
+
+``` yml
+en:
+  active_interaction:
+    attributes:
+      product:
+        num: 'Number'
+```
+
 ## Credits
 
 ActiveInteraction is brought to you by [Aaron Lasseigne][].

data/lib/active_interaction/array_input.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Represents a processed array input.
+  class ArrayInput < Input
+    # @private
+    def initialize(filter, value: nil, error: nil, index_errors: false, children: [])
+      super(filter, value: value, error: error)
+
+      @filter = filter
+      @index_errors = index_errors
+      @children = children
+    end
+
+    # @overload children
+    #   Child inputs if a nested filter is used.
+    #
+    #   @return [Array<Input, ArrayInput, HashInput>]
+    attr_reader :children
+
+    # Any errors that occurred during processing.
+    #
+    # @return [Filter::Error]
+    def errors
+      return @errors if defined?(@errors)
+
+      return @errors = super if @error
+
+      child_errors = get_errors_by_index(children)
+
+      return @errors = super if child_errors.empty?
+
+      @errors ||=
+        if @index_errors
+          child_errors.map do |(error, i)|
+            name = attach_child_name(:"#{@filter.name}[#{i}]", error)
+            Filter::Error.new(error.filter, error.type, name: name)
+          end.freeze
+        else
+          error, = child_errors.first
+          [Filter::Error.new(@filter, error.type)].freeze
+        end
+    end
+
+    private
+
+    def get_errors_by_index(children)
+      children.flat_map.with_index do |child, i|
+        child.errors.map do |error|
+          [error, i]
+        end
+      end
+    end
+
+    def attach_child_name(name, error)
+      return name unless error.name.present?
+
+      if children_are_arrays?(children)
+        :"#{name}#{error.name.to_s.sub(/\A[^\[]*/, '')}"
+      elsif children_are_hashes?(children)
+        :"#{name}.#{error.name.to_s[1..]}"
+      end
+    end
+
+    def children_are_arrays?(children)
+      return @children_are_arrays if defined?(@children_are_arrays)
+
+      @children_are_arrays = children.first&.is_a?(ArrayInput)
+    end
+
+    def children_are_hashes?(children)
+      return @children_are_hashes if defined?(@children_are_hashes)
+
+      @children_are_hashes = children.first&.is_a?(HashInput)
+    end
+  end
+end

data/lib/active_interaction/base.rb

@@ -30,7 +30,7 @@ module ActiveInteraction
     include ActiveRecordable
     include Runnable
 
-    define_callbacks :type_check
+    define_callbacks :filter
 
     class << self
       include Hashable
@@ -43,7 +43,7 @@ module ActiveInteraction
       #
       #   Runs validations and if there are no errors it will call {#execute}.
       #
-      #   @param (see ActiveInteraction::Inputs.process)
+      #   @param input [Hash, ActionController::Parameters]
       #
       #   @return [Base]
 
@@ -88,7 +88,8 @@ module ActiveInteraction
         # rubocop:enable Naming/MemoizedInstanceVariableName
       end
 
-      # @private
+      private
+
       # rubocop:disable Style/MissingRespondToMissing
       def method_missing(*args, &block)
         super do |klass, names, options|
@@ -99,8 +100,6 @@ module ActiveInteraction
       end
       # rubocop:enable Style/MissingRespondToMissing
 
-      private
-
       # @param klass [Class]
       # @param name [Symbol]
       # @param options [Hash]
@@ -162,7 +161,9 @@ module ActiveInteraction
     def initialize(inputs = {})
       @_interaction_raw_inputs = inputs
 
-      populate_filters_and_inputs(Inputs.process(inputs))
+      @_interaction_inputs = Inputs.new(inputs, self) do |name, input|
+        public_send("#{name}=", input.value)
+      end
     end
 
     # @!method compose(other, inputs = {})
@@ -186,113 +187,28 @@ module ActiveInteraction
     # Returns the inputs provided to {.run} or {.run!} after being cast based
     #   on the filters in the class.
     #
-    # @return [Hash{Symbol => Object}] All inputs passed to {.run} or {.run!}.
+    # @return [Inputs] All expected inputs passed to {.run} or {.run!}.
     def inputs
       @_interaction_inputs
     end
 
-    # Returns `true` if the given key was in the hash passed to {.run}.
-    # Otherwise returns `false`. Use this to figure out if an input was given,
-    # even if it was `nil`. Keys within nested hash filter can also be checked
-    # by passing them in series. Arrays can be checked in the same manor as
-    # hashes by passing an index.
-    #
-    # @example
-    #   class Example < ActiveInteraction::Base
-    #     integer :x, default: nil
-    #     def execute; given?(:x) end
-    #   end
-    #   Example.run!()        # => false
-    #   Example.run!(x: nil)  # => true
-    #   Example.run!(x: rand) # => true
-    #
-    # @example Nested checks
-    #   class Example < ActiveInteraction::Base
-    #     hash :x, default: {} do
-    #       integer :y, default: nil
-    #     end
-    #     array :a, default: [] do
-    #       integer
-    #     end
-    #     def execute; given?(:x, :y) || given?(:a, 2) end
-    #   end
-    #   Example.run!()               # => false
-    #   Example.run!(x: nil)         # => false
-    #   Example.run!(x: {})          # => false
-    #   Example.run!(x: { y: nil })  # => true
-    #   Example.run!(x: { y: rand }) # => true
-    #   Example.run!(a: [1, 2])      # => false
-    #   Example.run!(a: [1, 2, 3])   # => true
-    #
-    # @param input [#to_sym]
-    #
-    # @return [Boolean]
-    #
-    # @since 2.1.0
-    # rubocop:disable all
-    def given?(input, *rest)
-      filter_level = self.class
-      input_level = @_interaction_raw_inputs
-
-      [input, *rest].each do |key_or_index|
-        if key_or_index.is_a?(Symbol) || key_or_index.is_a?(String)
-          key = key_or_index.to_sym
-          key_to_s = key_or_index.to_s
-          filter_level = filter_level.filters[key]
-
-          break false if filter_level.nil? || input_level.nil?
-          if filter_level.accepts_grouped_inputs?
-            break false unless input_level.key?(key) || input_level.key?(key_to_s) || Inputs.keys_for_group?(input_level.keys, key)
-          else
-            break false unless input_level.key?(key) || input_level.key?(key_to_s)
-          end
-
-          input_level = input_level[key] || input_level[key_to_s]
-        else
-          index = key_or_index
-          filter_level = filter_level.filters.first.last
-
-          break false if filter_level.nil? || input_level.nil?
-          break false unless index.between?(-input_level.size, input_level.size - 1)
-
-          input_level = input_level[index]
-        end
-      end && true
+    # @private
+    def read_attribute_for_validation(attribute)
+      super(errors.local_attribute(attribute))
     end
-    # rubocop:enable all
 
     protected
 
     def run_validations!
-      type_check
+      filter
 
       super if errors.empty?
     end
 
     private
 
-    def populate_filters_and_inputs(inputs)
-      @_interaction_inputs = Inputs.new
-
-      self.class.filters.each do |name, filter|
-        value =
-          begin
-            filter.clean(inputs[name], self)
-          rescue InvalidValueError, MissingValueError, NoDefaultError
-            # #type_check will add errors if appropriate.
-            # We'll get the original value for the error.
-            inputs[name]
-          end
-
-        @_interaction_inputs[name] = value
-        public_send("#{name}=", value)
-      end
-
-      @_interaction_inputs.freeze
-    end
-
-    def type_check
-      run_callbacks(:type_check) do
+    def filter
+      run_callbacks(:filter) do
         Validation.validate(self, self.class.filters, inputs).each do |attr, type, kwargs = {}|
           errors.add(attr, type, **kwargs)
         end

data/lib/active_interaction/concerns/active_recordable.rb

@@ -17,15 +17,15 @@ module ActiveInteraction
     #   end
     #
     #   Interaction.new.column_for_attribute(:email)
-    #   # => #<ActiveInteraction::FilterColumn:0x007faebeb2a6c8 @type=:string>
+    #   # => #<ActiveInteraction::Filter::Column:0x007faebeb2a6c8 @type=:string>
     #
     #   Interaction.new.column_for_attribute(:not_a_filter)
     #   # => nil
     #
-    # @return [FilterColumn, nil]
+    # @return [Filter::Column, nil]
     def column_for_attribute(name)
       filter = self.class.filters[name]
-      FilterColumn.intern(filter.database_column_type) if filter
+      Filter::Column.intern(filter.database_column_type) if filter
     end
 
     # Returns true if a filter of that name exists.

data/lib/active_interaction/concerns/missable.rb

@@ -7,6 +7,8 @@ module ActiveInteraction
   module Missable
     extend ActiveSupport::Concern
 
+    private
+
     # @param slug [Symbol]
     #
     # @yield [klass, args, options]
@@ -26,8 +28,6 @@ module ActiveInteraction
       self
     end
 
-    private
-
     # @param slug [Symbol]
     #
     # @return [Filter, nil]