interactor_support 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99b9bd6793db476faba16087e24a939982b13974853c2a022e865e011509b143
-  data.tar.gz: 6980cdf3351816cbd8209825c03b58b82c195ac21c337d0638223a97c68814f8
+  metadata.gz: 9389f81b3832c245eac6c1f850a1b55c6baaebbc01be44eccd8d4f31c45bc731
+  data.tar.gz: c3ee7cd401d9d744e51208bc9763cb417e25410e4e2797bb51676aece17ffeec
 SHA512:
-  metadata.gz: ce6d5d43e59d7a70b8fa5e2183da93fc52644de5b12c796cf9b617e5a5eb5d78b32439e884cc40860e1bf2e7da6d1a926b58f9ed3257d2ced5ceb77a00c75715
-  data.tar.gz: 940bafa5fbf6d6178b0c8f5f603ff37995c178511aab9cb50d12acc15492a9ace497dbd1e66b76c12fbc3e6943d41d97a9ec557d5451bd3bb6e741e590316194
+  metadata.gz: 67218c44b1b89e1173abba43d298742eaa2bf59d7a884c5e65017c855f80a4ace05a2423232325395085f8e70c9d7f981e6ef39d267368e9eaf7c2c32fb7e57e
+  data.tar.gz: 0c8ff1bac440c0cd7f07d4e3f9463109986ce92240aaa5725e5d405f21c62040d6ea7509e1de2b951184db39cef977c181f01c73ed69895e599b67dda093628c

data/CHANGELOG.md

@@ -7,3 +7,7 @@
 ## [1.0.1] - 2025-03-26
 
 - Removed runtime requirements for rails and interactor.
+
+## [1.0.2] - 2025-03-28
+
+- Added support for mixing symbols and procs in the transformable concern

data/README.md

@@ -28,7 +28,7 @@ Make your **Rails interactors** clean, powerful, and less error-prone!
 Add to your Gemfile:
 
 ```sh
-bundle add interactor_support
+gem 'interactor_support', '~> 1.0', '>= 1.0.1'
 ```
 
 Or install manually:
@@ -84,7 +84,7 @@ class UpdateTodoTitle
   include Interactor
   include InteractorSupport
 
-  requires :todo_id, :title
+  required :todo_id, :title
   transform :title, with: :strip
   find_by :todo, query: { id: :todo_id }, required: true
   update :todo, attributes: { title: :title }
@@ -110,7 +110,7 @@ class CompleteTodo
   include InteractorSupport
 
   transaction
-  requires :todo_id
+  required :todo_id
   find_by :todo, query: { id: :todo_id }, required: true
 
   update :todo, attributes: {
@@ -133,7 +133,7 @@ class CompleteTodo
   include InteractorSupport
 
   transaction
-  requires :todo
+  required :todo
   skip if: -> { todo.completed? }
   update :todo, attributes: { completed: true, completed_at: -> { Time.current } }
 end
@@ -235,10 +235,53 @@ find_where :post, where: { user_id: :user_id }, context_key: :user_posts
 
 Provides `transform` to **sanitize and normalize inputs**.
 
+```rb
+# any method that the attribute responds to will work
+transform :title, with: :strip
+
+# You can chain transformers on an attribute
+# show_the_thing == "1" => "1".to_i.positive? => true
+transform :show_the_thing, with: [:to_i, :positive?]
+
+# transforming a string to a boolean using a lambda, eg: "true" => true
+transform :my_param, with: -> (val) { ActiveModel::Type::Boolean.new.cast(val) }
+
+# added in 1.0.2
+# mixing symbols and keys. eg: " True     " => true
+transform :my_param, with: [
+  :strip,
+  :downcase,
+  -> (val) { ActiveModel::Type::Boolean.new.cast(val) }
+]
+
+```
+
 #### 🔹 **`InteractorSupport::Concerns::Skippable`**
 
 Allows an interactor to **skip execution** if a condition is met.
 
+```rb
+# skips execution
+skip if: true
+# skips execution when a lambda is passed
+skip if: -> { true }
+# using a method
+skip if: :some_method?
+# using a context variable
+skip if: :condition
+
+# Using `unless`
+
+# skips execution
+skip unless: false
+# skips execution when a lambda is passed
+skip unless: -> { false }
+# using a method
+skip unless: :some_method?
+# using a context variable
+skip unless: :condition
+```
+
 #### 🔹 **`InteractorSupport::Validations`**
 
 Provides **automatic input validation** before execution. This includes `ActiveModel::Validations` and
@@ -274,6 +317,358 @@ If any validation fails, context.fail!(errors: errors.full_messages) will automa
 
 Provides structured, validated request objects based on **ActiveModel**.
 
+For now, here's the specs:
+
+```rb
+class GenreRequest
+  include InteractorSupport::RequestObject
+
+  attribute :title, transform: :strip
+  attribute :description, transform: :strip
+
+  validates :title, :description, presence: true
+end
+
+class LocationRequest
+  include InteractorSupport::RequestObject
+
+  attribute :city, transform: [:downcase, :strip]
+  attribute :country_code, transform: [:strip, :upcase]
+  attribute :state_code, transform: [:strip, :upcase]
+  attribute :postal_code, transform: [:strip, :clean_postal_code]
+  attribute :address, transform: :strip
+
+  validates :city, :postal_code, :address, presence: true
+  validates :country_code, :state_code, presence: true, length: { is: 2 }
+
+  def clean_postal_code(value)
+    value.to_s.gsub(/\D/, '')
+    value.first(5)
+  end
+end
+
+class AuthorRequest
+  include InteractorSupport::RequestObject
+
+  attribute :name, transform: :strip
+  attribute :email, transform: [:strip, :downcase]
+  attribute :age, transform: :to_i
+  attribute :location, type: LocationRequest
+  validates_format_of :email, with: URI::MailTo::EMAIL_REGEXP
+end
+
+class PostRequest
+  include InteractorSupport::RequestObject
+
+  attribute :user_id
+  attribute :title, transform: :strip
+  attribute :content, transform: :strip
+  attribute :genre, type: GenreRequest
+  attribute :authors, type: AuthorRequest, array: true
+end
+
+RSpec.describe(InteractorSupport::RequestObject) do
+  describe 'attribute transformation' do
+    before do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_self
+      end
+    end
+    context 'when using a single transform' do
+      it 'strips the value for a symbol transform' do
+        genre = GenreRequest.new(title: '  Science Fiction  ', description: ' A genre of speculative fiction  ')
+        expect(genre.title).to(eq('Science Fiction'))
+        expect(genre.description).to(eq('A genre of speculative fiction'))
+      end
+    end
+
+    context 'when using an array of transforms' do
+      it 'applies all transform methods in order' do
+        buyer = LocationRequest.new(
+          city: '  New York  ',
+          country_code: '  us  ',
+          state_code: '  ny  ',
+          postal_code: '  10001-5432  ',
+          address: '  123 Main St.  ',
+        )
+        expect(buyer.city).to(eq('new york'))
+        expect(buyer.country_code).to(eq('US'))
+        expect(buyer.state_code).to(eq('NY'))
+        expect(buyer.postal_code).to(eq('10001'))
+        expect(buyer.address).to(eq('123 Main St.'))
+      end
+    end
+
+    context 'when the value does not respond to a transform method' do
+      it 'raises and argument error if the transform method is not defined' do
+        class DummyRequest
+          include InteractorSupport::RequestObject
+          attribute :number, transform: :strip
+          validates :number, presence: true
+        end
+
+        expect { DummyRequest.new(number: 1234) }.to(raise_error(ArgumentError))
+      end
+    end
+  end
+
+  describe 'nesting request objects and array support' do
+    before do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_self
+      end
+    end
+    context 'when using a type without array' do
+      it "wraps the given hash in the type's new instance" do
+        post = PostRequest.new(
+          user_id: 1,
+          title: '  My First Post  ',
+          content: '  This is the content of my first post  ',
+          genre: { title: '  Science Fiction  ', description: ' A genre of speculative fiction  ' },
+          authors: [
+            {
+              name: '  John Doe  ',
+              email: 'me@mail.com',
+              age: '  25  ',
+              location: {
+                city: '  New York  ',
+                country_code: '  us  ',
+                state_code: '  ny  ',
+                postal_code: '  10001-5432  ',
+                address: '  123 Main St.  ',
+              },
+            },
+            {
+              name: '  Jane Doe  ',
+              email: 'you@mail.com',
+              age: '  25  ',
+              location: {
+                city: '  Los Angeles  ',
+                country_code: '  us  ',
+                state_code: '  ca  ',
+                postal_code: '  90001  ',
+                address: '  456 Elm St.  ',
+              },
+            },
+          ],
+        )
+
+        expect(post).to(be_valid)
+        expect(post.user_id).to(eq(1))
+        expect(post.title).to(eq('My First Post'))
+        expect(post.content).to(eq('This is the content of my first post'))
+        expect(post.genre).to(be_a(GenreRequest))
+        expect(post.genre.title).to(eq('Science Fiction'))
+        expect(post.genre.description).to(eq('A genre of speculative fiction'))
+        expect(post.authors).to(be_an(Array))
+        expect(post.authors.size).to(eq(2))
+        post.authors.each do |author|
+          expect(author).to(be_a(AuthorRequest))
+          expect(author).to(be_valid)
+          expect(author.location).to(be_a(LocationRequest))
+          expect(author.location).to(be_valid)
+          expect(author.location.city).to(be_in(['new york', 'los angeles']))
+          expect(author.location.country_code).to(eq('US'))
+          expect(author.location.state_code).to(be_in(['NY', 'CA']))
+          expect(author.location.postal_code).to(be_in(['10001', '90001']))
+          expect(author.location.address).to(be_in(['123 Main St.', '456 Elm St.']))
+        end
+      end
+    end
+  end
+
+  describe 'to_context' do
+    before do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_self
+      end
+    end
+    it 'returns a struct and includes nested attributes' do
+      context = PostRequest.new(
+        user_id: 1,
+        title: '  My First Post  ',
+        content: '  This is the content of my first post  ',
+        genre: { title: '  Science Fiction  ', description: ' A genre of speculative fiction  ' },
+        authors: [
+          {
+            name: '  John Doe  ',
+            email: 'a@b.com',
+            age: '  25  ',
+            location: {
+              city: '  New York  ',
+              country_code: '  us  ',
+              state_code: '  ny  ',
+              postal_code: '  10001-5432  ',
+              address: '  123 Main St.  ',
+            },
+          },
+        ],
+      ).to_context
+
+      expect(context).to(be_a(Hash))
+      expect(context[:user_id]).to(eq(1))
+      expect(context[:title]).to(eq('My First Post'))
+      expect(context[:content]).to(eq('This is the content of my first post'))
+      expect(context[:genre]).to(be_a(Hash))
+      expect(context.dig(:genre, :title)).to(eq('Science Fiction'))
+      expect(context.dig(:genre, :description)).to(eq('A genre of speculative fiction'))
+      expect(context[:authors]).to(be_an(Array))
+      expect(context[:authors].size).to(eq(1))
+      author = context[:authors].first
+      expect(author).to(be_a(Hash))
+      expect(author[:name]).to(eq('John Doe'))
+      expect(author[:email]).to(eq('a@b.com'))
+      expect(author[:age]).to(eq(25))
+      expect(author[:location]).to(be_a(Hash))
+      expect(author[:location][:city]).to(eq('new york'))
+      expect(author[:location][:country_code]).to(eq('US'))
+    end
+  end
+
+  describe 'configured request object behavior' do
+    it 'returns a context hash with symbol keys when configured to do so' do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_context
+        config.request_object_key_type = :symbol
+      end
+
+      context = PostRequest.new(
+        user_id: 1,
+        title: '  My First Post  ',
+        content: '  This is the content of my first post  ',
+        genre: { title: '  Science Fiction  ', description: ' A genre of speculative fiction  ' },
+        authors: [
+          {
+            name: '  John Doe  ',
+            email: 'j@j.com',
+            age: '  25  ',
+            location: {
+              city: '  New York  ',
+              country_code: '  us  ',
+              state_code: '  ny  ',
+              postal_code: '  10001-5432  ',
+              address: '  123 Main St.  ',
+            },
+          },
+        ],
+      )
+
+      expect(context).to(be_a(Hash))
+      expect(context[:user_id]).to(eq(1))
+      expect(context[:title]).to(eq('My First Post'))
+      expect(context[:content]).to(eq('This is the content of my first post'))
+      expect(context[:genre]).to(be_a(Hash))
+      expect(context.dig(:genre, :title)).to(eq('Science Fiction'))
+      expect(context.dig(:genre, :description)).to(eq('A genre of speculative fiction'))
+      expect(context[:authors]).to(be_an(Array))
+      expect(context[:authors].size).to(eq(1))
+      author = context[:authors].first
+      expect(author).to(be_a(Hash))
+      expect(author[:name]).to(eq('John Doe'))
+      expect(author[:email]).to(eq('j@j.com'))
+      expect(author[:age]).to(eq(25))
+      expect(author[:location]).to(be_a(Hash))
+      expect(author[:location][:city]).to(eq('new york'))
+      expect(author[:location][:country_code]).to(eq('US'))
+    end
+
+    it 'returns a context hash with string keys when configured to do so' do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_context
+        config.request_object_key_type = :string
+      end
+
+      post = PostRequest.new(
+        user_id: 1,
+        title: '  My First Post  ',
+        content: '  This is the content of my first post  ',
+        genre: { title: '  Science Fiction  ', description: ' A genre of speculative fiction  ' },
+        authors: [
+          {
+            name: '  John Doe  ',
+            email: 'j@j.com',
+            age: '  25  ',
+            location: {
+              city: '  New York  ',
+              country_code: '  us  ',
+              state_code: '  ny  ',
+              postal_code: '  10001-5432  ',
+              address: '  123 Main St.  ',
+            },
+          },
+        ],
+      )
+
+      context = post
+      expect(context).to(be_a(Hash))
+      expect(context['user_id']).to(eq(1))
+      expect(context['title']).to(eq('My First Post'))
+      expect(context['content']).to(eq('This is the content of my first post'))
+      expect(context['genre']).to(be_a(Hash))
+      expect(context.dig('genre', 'title')).to(eq('Science Fiction'))
+      expect(context.dig('genre', 'description')).to(eq('A genre of speculative fiction'))
+      expect(context['authors']).to(be_an(Array))
+      expect(context['authors'].size).to(eq(1))
+      author = context['authors'].first
+      expect(author).to(be_a(Hash))
+      expect(author['name']).to(eq('John Doe'))
+      expect(author['email']).to(eq('j@j.com'))
+      expect(author['age']).to(eq(25))
+      expect(author['location']).to(be_a(Hash))
+      expect(author['location']['city']).to(eq('new york'))
+      expect(author['location']['country_code']).to(eq('US'))
+    end
+
+    it 'returns a context struct when configured to do so' do
+      InteractorSupport.configure do |config|
+        config.request_object_behavior = :returns_context
+        config.request_object_key_type = :struct
+      end
+
+      post = PostRequest.new(
+        user_id: 1,
+        title: '  My First Post  ',
+        content: '  This is the content of my first post  ',
+        genre: { title: '  Science Fiction  ', description: ' A genre of speculative fiction  ' },
+        authors: [
+          {
+            name: '  John Doe  ',
+            email: 'j@j.com',
+            age: '  25  ',
+            location: {
+              city: '  New York  ',
+              country_code: '  us  ',
+              state_code: '  ny  ',
+              postal_code: '  10001-5432  ',
+              address: '  123 Main St.  ',
+            },
+          },
+        ],
+      )
+
+      context = post
+      expect(context).to(be_a(Struct))
+      expect(context.user_id).to(eq(1))
+      expect(context.title).to(eq('My First Post'))
+      expect(context.content).to(eq('This is the content of my first post'))
+      expect(context.genre).to(be_a(Struct))
+      expect(context.genre.title).to(eq('Science Fiction'))
+      expect(context.genre.description).to(eq('A genre of speculative fiction'))
+      expect(context.authors).to(be_an(Array))
+      expect(context.authors.size).to(eq(1))
+      author = context.authors.first
+      expect(author).to(be_a(Struct))
+      expect(author.name).to(eq('John Doe'))
+      expect(author.email).to(eq('j@j.com'))
+      expect(author.age).to(eq(25))
+      expect(author.location).to(be_a(Struct))
+      expect(author.location.city).to(eq('new york'))
+      expect(author.location.country_code).to(eq('US'))
+    end
+  end
+end
+```
+
 ## 🤝 **Contributing**
 
 Pull requests are welcome on [GitHub](https://github.com/charliemitchell/interactor_support).

data/lib/interactor_support/concerns/transformable.rb

@@ -42,11 +42,20 @@ module InteractorSupport
                     context.fail!(errors: ["#{key} failed to transform: #{e.message}"])
                   end
                 elsif with.is_a?(Array)
-                  context.fail!(errors: ["#{key} does not respond to all transforms"]) unless with.all? do |t|
-                    t.is_a?(Symbol) && context[key].respond_to?(t)
-                  end
-                  context[key] = with.inject(context[key]) do |value, method|
-                    value.send(method)
+                  with.each do |method|
+                    if method.is_a?(Proc)
+                      begin
+                        context[key] = context.instance_exec(&method)
+                      rescue => e
+                        context.fail!(errors: ["#{key} failed to transform: #{e.message}"])
+                      end
+                    else
+                      context.fail!(
+                        errors: ["#{key} does not respond to all transforms"],
+                      ) unless context[key].respond_to?(method)
+
+                      context[key] = context[key].send(method)
+                    end
                   end
                 elsif with.is_a?(Symbol) && context[key].respond_to?(with)
                   context[key] = context[key].send(with)

data/lib/interactor_support/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module InteractorSupport
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interactor_support
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Charlie Mitchell
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-26 00:00:00.000000000 Z
+date: 2025-03-28 00:00:00.000000000 Z
 dependencies: []
 description:
 email: