active_interaction 4.0.5 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc966bbcee80b29757efdf5bf0b6b0357b8d24610dca49017f4a8cdca64bfaa3
-  data.tar.gz: fe255f995b77c90c935fb14ae05660fcc973a3e7ef3e26209d5e1e187624ca21
+  metadata.gz: 0cfed756a5463384a07d694ba40f14067dce231d2618af2f16e6fd429e31b97f
+  data.tar.gz: eb3b185d234762dec1799fbaa6e8acf290a47e0940b24c3da529f11172e6fde5
 SHA512:
-  metadata.gz: 233b8b4334a5f4d34d12607c054a47aa4839f9c734cd251b682f30173aaa5115e0d8292c0074efd21137a966831b635d2a4e4f3c55f6cb282bb78ed6f795450e
-  data.tar.gz: a5fef4055b48c4c72f3f297f52260f0fe4055a2299961d0fd70ebfd7fcfadc2814628a01cec947259e4b99620fc9a2ee313baaa373449aadeba62829eea7be00
+  metadata.gz: b2ce2d6ef28bc84e2cc614dd9e6dde57c14a92efcafe706e8cb532b1c0fa9c192db8548771b94198236f3ab3ec6baa9633c2625c3f8b73cbcc1291752078be6c
+  data.tar.gz: 3f5f3c15059c19c7fec77256a260fc67f98444ab5dba48048f2797a441a348f7deea31b7b558e0b1af334ffd8a6e1685756745ecebdc87ee658dafc42f8043c4

data/CHANGELOG.md

@@ -1,32 +1,169 @@
+# [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
+
+- [#518][] - Add Rails 7 support
+
+# [4.0.6][] (2021-10-13)
+
+## Fixed
+
+- [#515][] - Filters nested in arrays should accept default values as indicated in the documentation.
+
 # [4.0.5][] (2021-07-11)
 
-## Fix
+## Fixed
 
 - [#480][] - Interfaces used inside hashes failed to recognize `nil` as a non-value.
 
 # [4.0.4][] (2021-07-03)
 
-## Fix
+## Fixed
 
 - [#510][] - Hash parameters failed when working outside of Rails.
 - [#511][] - Nested filters with options but no `:class` failed to have `:class` automatically added.
 
 # [4.0.3][] (2021-06-24)
 
-## Fix
+## Fixed
 
 - [#499][] - `given?` now recognizes multi-part date inputs by their primary key name
 - [#493][] - `compose` now properly accepts `Inputs`
 
 # [4.0.2][] (2021-06-22)
 
-## Fix
+## Fixed
 
 - [#505][] - Nested Interface filters using the `:methods` option threw an error.
 
 # [4.0.1][] (2021-05-26)
 
-## Fix
+## Fixed
 
 - Fix regression of filter name relaxing.
 - [#495][] - Fix time filter ignoring time zones
@@ -56,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
@@ -964,6 +1101,9 @@ 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
   [4.0.4]: https://github.com/AaronLasseigne/active_interaction/compare/v4.0.3...v4.0.4
   [4.0.3]: https://github.com/AaronLasseigne/active_interaction/compare/v4.0.2...v4.0.3
@@ -1182,3 +1322,6 @@ Example.run
   [#511]: https://github.com/AaronLasseigne/active_interaction/issues/511
   [#412]: https://github.com/AaronLasseigne/active_interaction/issues/412
   [#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,11 +1,10 @@
 # [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)
-[![Climate](https://img.shields.io/codeclimate/maintainability/orgsync/active_interaction.svg?style=flat-square)](https://codeclimate.com/github/orgsync/active_interaction)
 
 ---
 
@@ -52,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)
@@ -64,18 +63,17 @@ handles your verbs.
 Add it to your Gemfile:
 
 ``` rb
-gem 'active_interaction', '~> 4.0'
+gem 'active_interaction', '~> 5.0'
 ```
 
 Or install it manually:
 
 ``` sh
-$ gem install active_interaction --version '~> 4.0'
+$ 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
 
@@ -90,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
@@ -142,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.
@@ -165,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
@@ -262,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"`
@@ -465,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
@@ -493,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
@@ -737,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/
@@ -843,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
 
@@ -1020,13 +1042,13 @@ end
 
 ### Callbacks
 
-ActiveModel provides a powerful framework for defining callbacks.
-ActiveInteraction hooks into that framework to allow hooking into various parts
-of an interaction's lifecycle.
+[ActiveSupport::Callbacks][] provides a powerful framework for defining callbacks.
+ActiveInteraction uses that framework to allow hooking into various parts of an
+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
 
@@ -1048,7 +1070,7 @@ class Increment < ActiveInteraction::Base
 end
 
 Increment.run!(x: 1)
-# before type check
+# before filter
 # after validate
 # >>>
 # executing
@@ -1056,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
@@ -1179,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
@@ -1188,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
@@ -1338,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
@@ -1359,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.
 
@@ -1371,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
@@ -1425,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
 ```
@@ -1445,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][].
@@ -1471,3 +1505,4 @@ ActiveInteraction is licensed under [the MIT License][].
 [the errors section]: #errors
 [the optional inputs section]: #optional-inputs
 [`with_options`]: http://api.rubyonrails.org/classes/Object.html#method-i-with_options
+[ActiveSupport::Callbacks]: https://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html

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