interactify 0.2.0.pre.alpha.1 → 0.3.0.pre.RC1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c2dffe1928c3b1653ea12057fd660eacbef1d8fbd946d1bdbddef00494a8c8b
-  data.tar.gz: 7078fe7a6b217febd47f4598eb2e88fdcfb8affcd434dba239ee86a39a072176
+  metadata.gz: 319dd56313d82aa987c8eaec40691e43c58e8b72513969e2a6a7a83de17ae311
+  data.tar.gz: 3f5e4ad0464157910bca7bfd1300fa8e23ab825068c84a4c5c0ef5ad0cdb29d6
 SHA512:
-  metadata.gz: 9e3eb106e5b896965c6b1fbfea135c62f4eb7f95779041c121bcb2040fd8568c54e94b4f77a3e1bcca6d922d8a8bdfcacda354d3a6396e19a49fbfce78f39af1
-  data.tar.gz: 3f998d9f35105a47becc0555ed80dff264fad2e5fe58f93ec0c731b8cab4281e457da9e3fc00d0e4709e1b62b4e2416a8a75b66f56723b610531bca8fd458ea3
+  metadata.gz: fea0120a4456f108b41ccd48c994e365762bad8ff6424eba9d7ecd0c09c6858805e0456df0655eec86042ed7dc9fa589ffb8f3bdb49a14e79a7e05e30b6737ae
+  data.tar.gz: 64345da2e8b036ad65c639bddb9c0f90f93b1fdbc1415a5cb29f26596fa9169c6a9b0309d9d0ecbb515706251ff473f4ac98f7b41be7d89c089ce3b8537ade54

data/.ruby-version

@@ -0,0 +1 @@
+3.1.4

data/Appraisals

@@ -0,0 +1,21 @@
+appraise "railties-7-sidekiq" do
+  gem "railties", "7"
+  gem "sidekiq", "7"
+end
+
+appraise "railties-7-no-sidekiq" do
+  gem "railties", "7"
+end
+
+appraise "railties-6-sidekiq" do
+  gem "railties", "6"
+  gem "sidekiq", "7"
+end
+
+appraise "railties-6-no-sidekiq" do
+  gem "railties", "6"
+end
+
+appraise "no-railties-no-sidekiq" do
+  # nothing extra
+end

data/CHANGELOG.md

@@ -1,9 +1,22 @@
 ## [Unreleased]
 
-## [0.1.0] - 2023-12-16
+## [0.1.0-alpha.1] - 2023-12-16
 
 - Initial release
 
-## [0.2.0] - 2023-12-27
+## [0.2.0-alpha.1] - 2023-12-27
 
 - Added support for Interactify.promising syntax in organizers
+
+## [0.3.0-alpha.1] - 2023-12-29
+
+- Added support for `{if: :condition, then: A, else: B}` in organizers
+
+## [0.3.0-alpha.2] - 2023-12-29
+
+- Remove deep_matching development dependency
+
+## [0.3.0-RC1] - 2023-12-29
+
+- Fixed to work with and make optional dependencies for sidekiq and railties. Confirmed as working with ruby >= 3.1.4
+

data/README.md

@@ -1,24 +1,28 @@
 # Interactify
 
-[Interactors](https://github.com/collectiveidea/interactor) are a great way to encapsulate business logic in a Rails application. 
-However, sometimes in complex interactor chains, the complex debugging happens at one level up from your easy to read and test interactors.
-
-[interactor-contracts](https://github.com/michaelherold/interactor-contracts) does a fantastic job of making your interactor chains more reliable.
-
-Interactify wraps the interactor and interactor-contracts gem and provides additional functionality making chaining and understanding interactor chains easier.
-
-This is a bells and whistles gem and assumes you are working in a Rails project with Sidekiq.
-However, I'm open to the idea of making it more focused and making these more pluggable.
+[![Gem Version](https://badge.fury.io/rb/interactify.svg)](https://badge.fury.io/rb/interactify)
+![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=markburns/interactify)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+![Ruby 3.3.0](https://img.shields.io/badge/ruby-3.3.0-green.svg)
+![Ruby 3.2.2](https://img.shields.io/badge/ruby-3.2.2-green.svg)
+![Ruby 3.1.4](https://img.shields.io/badge/ruby-3.1.4-green.svg)
+[![Code Climate](https://codeclimate.com/github/markburns/interactify/badges/gpa.svg)](https://codeclimate.com/github/markburns/interactify)
+
+Interactify enhances Rails applications by simplifying complex interactor chains. 
+This gem builds on [interactors](https://github.com/collectiveidea/interactor) and [interactor-contracts](https://github.com/michaelherold/interactor-contracts) to improve readability and maintainability of business logic. 
+We depend on activesupport, and optionally on railties and sidekiq. So it's a good fit for Rails projects using Sidekiq, offering advanced features for chain management and debugging. 
+Interactify is about making interactor usage in Rails more efficient and less error-prone, reducing the overhead of traditional interactor orchestration.
 
 ## Installation
 
-```Gemfile
+```ruby
 gem 'interactify'
 ```
 
 ## Usage
 
 ### Initializer
+
 ```ruby
 # in config/initializers/interactify.rb
 Interactify.configure do |config|
@@ -39,10 +43,15 @@ end
 ```ruby
 # e.g. in spec/supoort/interactify.rb
 require 'interactify/rspec/matchers'
+
+expect(described_class).to expect_inputs(:foo, :bar, :baz)
+expect(described_class).to promise_outputs(:fee, :fi, :fo, :fum)
 ```
 
 ### Syntactic Sugar
 - Everything is an Organizer/Interactor and supports interactor-contracts.
+- They only becomes considered an organizer once `organize` is called.
+- They could technically be both (if you want?) but you have to remember to call `super` within `call` to trigger the organized interactors.
 - Concise syntax for most common scenarios with `expects` and `promises`. Verifying the presence of the keys/values.
 - Automatic delegation of expected and promised keys to the context.
 
@@ -63,7 +72,6 @@ class LoadOrder
     required(:order).filled
   end
 
-
   def call
     context.order = Order.find(context.id)
   end
@@ -89,8 +97,8 @@ end
 
 ### Lambdas
 
-With vanilla interactors, it's not possible to use lambdas in organizers, and sometimes we only want a lambda.
-So we added support.
+With vanilla interactors, it wasn't possible to use lambdas in organizers.
+But sometimes we only want a lambda. So we added support.
 
 ```ruby
 organize LoadOrder, ->(context) { context.order = context.order.decorate }
@@ -157,7 +165,6 @@ class DoSomethingWithOrder
 end
 ```
 
-
 ```ruby
 # after
 class OuterOrganizer
@@ -178,7 +185,6 @@ class LoadOrder
   end
 end
 
-
 class DoSomethingWithOrder
   # ... boilerplate ...
   def call
@@ -187,7 +193,7 @@ class DoSomethingWithOrder
 end
 ```
 
-### Conditionals (if/else)
+### Conditionals (if/else) with lambda
 
 Along the same lines of each/iteration. We sometimes have to 'break the chain' with interactors just to conditionally call one interactor chain path or another.
 
@@ -212,26 +218,22 @@ class InnerThing
 end
 ```
 
-
 ```ruby
 # after
 class OuterThing
   # ... boilerplate ...
   organize \
     SetupStep,
-    self.if(->(c){ c.thing == 'a' }, DoThingA, DoThingB),
-end
 
-```
+    # lambda conditional
+    self.if(->(c){ c.thing == 'a' }, DoThingA, DoThingB),
 
-### More Conditionals 
+    # context conditional
+    self.if(:some_key_on_context, DoThingA, DoThingB),
 
-```ruby
-class OuterThing
-  # ... boilerplate ...
-  organize \
-    self.if(:key_set_on_context, DoThingA, DoThingB),
-    AfterBothCases
+    # alternative hash syntax
+    {if: :key_set_on_context, then: DoThingA, else: DoThingB},
+    AfterDoThis
 end
 ```
 
@@ -251,6 +253,7 @@ class SomeOrganizer
 end
 
 ```
+
 ### Contract validation failures
 Sometimes contract validation fails at runtime as an exception. It's something unexpected and you'll have an `Interactor::Failure` sent to rollbar/sentry/honeybadger.
 If the context is large it's often hard to spot what the actual problem is or where it occurred.
@@ -299,7 +302,6 @@ Actual promises are:
 step1
 ```
 
-
 ### Interactor wiring specs
 Sometimes you have an interactor chain that fails because something is expected deeper down the chain and not provided further up the chain. 
 The existing way to solve this is with enough integration specs to catch them, hunting and sticking a `byebug`, `debugger` or `binding.pry` in at suspected locations and inferring where in the chain the wiring went awry.
@@ -339,55 +341,33 @@ expect(described_class).to promise_outputs(:order)
 ### Sidekiq Jobs
 Sometimes you want to asyncify an interactor.
 
-```ruby
-# before
-class SomeInteractor
-  include Interactify
-
-  def call
-    # ...
-  end
-end
-
-clsas SomeInteractorJob
-  include Sidekiq::Job
-
-  def perform(*args)
-    SomeInteractor.call(*args)
-  end
-end
-```
-
+#### before
 ```diff
--SomeInteractor.call(*args)
-+SomeInteractorJob.perform_async(*args)
+- SomeInteractor.call(*args)
++ class SomeInteractorJob
++   include Sidekiq::Job
++
++   def perform(*args)
++     SomeInteractor.call(*args)
++   end
++ end
++
++ SomeInteractorJob.perform_async(*args)
 ```
 
-```ruby
-# after
-class SomeInteractor
-  include Interactify
-
-  def call
-    # ...
-  end
-end
+#### after
+```diff
+- SomeInteractor.call!(*args)
++ SomeInteractor::Async.call!(*args)
 ```
 
 No need to manually create a job class or handle the perform/call impedance mismatch
 
-```diff
--SomeInteractor.call!(*args)
-+SomeInteractor::Async.call!(*args)
-```
-
 This also makes it easy to add cron jobs to run interactors. As any interactor can be asyncified.
 By using it's internal Async class.
 
 N.B. as your class is now executing asynchronously you can no longer rely on its promises later on in the chain.
 
-
-
 ## FAQs
 - This is ugly isn't it?
 
@@ -403,73 +383,33 @@ class OuterOrganizer
     )
 end
 ```
+1. Do you find the syntax of OuterOrganizer ugly?
 
-Yes I agree. It's early days and I'm open to syntax improvement ideas. This is really about it being conceptually less ugly than the alternative, which is to jump around between lots of files. In the existing alternative to using this gem the ugliness is not within each individual file, but within the overall hidden architecture and the hunting process of jumping around in complex interactor chains. We can't see that ugliness but we probably experience it. If you don't feel or experience that ugliness then this gem may not be the right fit for you.
+While the syntax might seem unconventional initially, its conceptual elegance lies in streamlining complex interactor chains. Traditional methods often involve navigating through multiple files, creating a hidden and cumbersome architecture. This gem aims to alleviate that by centralizing operations, making the overall process more intuitive.
 
+2. Is this compatible with interactor/interactor-contracts?
 
-- Is this interactor/interactor-contracts compatible? 
-Yes and we use them as dependencies. It's possible we'd drop those dependencies in the future but unlikely. I think it's highly likely we'd retain compatibility.
+Yes, it's fully compatible. We currently use these as dependencies. While there's a possibility of future changes, maintaining this compatibility is a priority.
 
+3. Why not suggest enhancements to the interactor or interactor-contracts gems?
 
-- Why not propose changes to the interactor or interactor-contracts gem?
-Honestly, I think both are great and why we've built on top of them. 
-I presume they'd object to such an extensive opinionated change, and I think that would be the right decision too.
-If this becomes more stable, less coupled to Rails, there's interest, and things we can provide upstream I'd be happy to propose changes to those gems.
-
-- Isn't this all just syntactic sugar?
-Yes, but it's sugar that makes the code easier to read and understand.
-
-- Is it really easier to parse this new DSL/syntax than POROs?
-That's subjective, but I think so. The benefit is you have fewer extraneous files patching over a common problem in interactors.
-
-- But it gets really verbose and complex!
-Again this is subjective, but if you've worked with apps with hundred or thousands of interactors, you'll have encountered these problems.
-I think when we work with interactors we're in one of two modes. 
-Hunting to find the interactor we need to change, or working on the interactor we need to change.
-This makes the first step much easier. 
-The second step has always been a great experience with interactors.
-
-- I prefer Service Objects
-If you're not heavily invested into interactors this may not be for you.
-I love the chaining interactors provide. 
-I love the contracts. 
-I love the simplicity of the interface.
-I love the way they can be composed. 
-I love the way they can be tested.
-When I've used service objects, I've found them to be more complex to test and compose.
-I can't see a clean way that using service objects to compose interactors could work well without losing some of the aforementioned benefits.
-
-### TODO
-We want to add support for explicitly specifying promises in organizers. 
-
-The benefit here is on clarifying the contract between organizers and interactors.
-
-This is another variation of the "interactors themselves are great but their coordination and finding where things happen is hard in large applications".
-
-By adding promise notation to organizers, we can signal to the reader that 'here in this part of the chain is the thing you are looking for'.
-
-A writer of an organizer may expect LoadOrder to promise :order, but for the reader, it's not quite as explicit.
-The expected syntax will be
-
-```ruby
-organize \
-  LoadOrder.promising(:order), 
-  TakePayment.promising(:payment_transaction)
-```
+These gems are excellent in their own right, which is why we've built upon them. Proposing such extensive changes might not align with their current philosophy. However, if our approach proves stable and garners interest, we're open to discussing potential contributions to these gems.
 
-This will be validated at test time against the interactors promises.
+4. Is this just syntactic sugar?
 
+It's more than that. This approach enhances readability and comprehension of the code. It simplifies the structure, making it easier to navigate and maintain.
 
-## Development
+5. Is the new DSL/syntax easier to understand than plain old Ruby objects (POROs)?
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+This is subjective, but we believe it is. It reduces the need for numerous files addressing common interactor issues, thereby streamlining the workflow.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+6. Doesn't this approach become verbose and complex in large applications?
 
-## Contributing
+While it may appear so, this method shines in large-scale applications with numerous interactors. It simplifies locating and modifying the necessary interactors, which is often a cumbersome process.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/interactify.
+7. What if I prefer using Service Objects?
 
+That's completely valid. Service Objects have their merits, but this gem is particularly useful for those deeply engaged with interactors. It capitalizes on the chaining, contracts, simplicity, composability, and testability that interactors offer. Combining Service Objects with interactors might not retain these advantages as effectively.
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/no_railties_no_sidekiq.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+
+group :development do
+  gem "bundler", "~> 2.0"
+end
+
+group :test do
+  gem "simplecov", require: false
+  gem "rspec", "~> 3.0"
+end
+
+gemspec path: "../"

data/gemfiles/no_railties_no_sidekiq.gemfile.lock

@@ -0,0 +1,127 @@
+PATH
+  remote: ..
+  specs:
+    interactify (0.3.0.pre.alpha.2)
+      activesupport (>= 6.0.0)
+      interactor
+      interactor-contracts
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    appraisal (2.5.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    base64 (0.2.0)
+    bigdecimal (3.1.5)
+    concurrent-ruby (1.2.2)
+    connection_pool (2.4.1)
+    debug (1.9.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    drb (2.2.0)
+      ruby2_keywords
+    dry-configurable (1.0.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-initializer (3.1.1)
+    dry-logic (1.5.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-schema (1.13.3)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 1.0, >= 1.0.1)
+      dry-core (~> 1.0, < 2)
+      dry-initializer (~> 3.0)
+      dry-logic (>= 1.4, < 2)
+      dry-types (>= 1.7, < 2)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
+      zeitwerk (~> 2.6)
+    dry-validation (1.10.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      dry-initializer (~> 3.0)
+      dry-schema (>= 1.12, < 2)
+      zeitwerk (~> 2.6)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    interactor (3.1.2)
+    interactor-contracts (0.3.0)
+      dry-validation (~> 1.0)
+      interactor (~> 3)
+    io-console (0.7.1)
+    irb (1.11.0)
+      rdoc
+      reline (>= 0.3.8)
+    minitest (5.20.0)
+    mutex_m (0.2.0)
+    psych (5.1.2)
+      stringio
+    rake (13.1.0)
+    rdoc (6.6.2)
+      psych (>= 4.0.0)
+    reline (0.4.1)
+      io-console (~> 0.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    ruby2_keywords (0.0.5)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    stringio (3.1.0)
+    thor (1.3.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  bundler (~> 2.0)
+  debug
+  interactify!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  simplecov
+
+BUNDLED WITH
+   2.4.22

data/gemfiles/railties_6.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "simplecov", require: false
+gem "rake", "~> 13.0"
+gem "railties", "6"
+gem "sidekiq", "7"
+
+group :test do
+  gem "rspec", "~> 3.0"
+end
+
+gemspec path: "../"