interactify 0.1.0.pre.alpha.1 → 0.3.0.pre.alpha.1

data/lib/interactify/interactor_wrapper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "interactify/unique_klass_name"
+
+module Interactify
+  class InteractorWrapper
+    attr_reader :organizer, :interactor
+
+    def self.wrap_many(organizer, interactors)
+      Array(interactors).map do |interactor|
+        wrap(organizer, interactor)
+      end
+    end
+
+    def self.wrap(organizer, interactor)
+      new(organizer, interactor).wrap
+    end
+
+    def initialize(organizer, interactor)
+      @organizer = organizer
+      @interactor = interactor
+    end
+
+    def wrap
+      case interactor
+      when Hash
+        wrap_conditional
+      when Array
+        wrap_chain
+      when Proc
+        wrap_proc
+      else
+        interactor
+      end
+    end
+
+    def wrap_chain
+      return self.class.wrap(organizer, interactor.first) if interactor.length == 1
+
+      klass_name = UniqueKlassName.for(organizer, "Chained")
+      organizer.chain(klass_name, *interactor.map { self.class.wrap(organizer, _1) })
+    end
+
+    def wrap_conditional
+      raise ArgumentError, "Hash must have at least :if, and :then key" unless condition && then_do
+
+      return organizer.if(condition, then_do, else_do) if else_do
+
+      organizer.if(condition, then_do)
+    end
+
+    def condition = interactor[:if]
+    def then_do = interactor[:then]
+    def else_do = interactor[:else]
+
+    def wrap_proc
+      this = self
+
+      Class.new do
+        include Interactify
+
+        define_singleton_method :wrapped do
+          this.interactor
+        end
+
+        define_method(:call) do
+          this.interactor.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/interactify/job_maker.rb

@@ -1,5 +1,9 @@
-require 'sidekiq'
-require 'sidekiq/job'
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/job"
+
+require "interactify/async_job_klass"
 
 module Interactify
   class JobMaker
@@ -13,93 +17,40 @@ module Interactify
     end
 
     concerning :JobClass do
-      def job_class
-        @job_class ||= define_job_class
+      def job_klass
+        @job_klass ||= define_job_klass
       end
 
       private
 
-      def define_job_class
+      def define_job_klass
         this = self
 
         invalid_keys = this.opts.symbolize_keys.keys - %i[queue retry dead backtrace pool tags]
 
         raise ArgumentError, "Invalid keys: #{invalid_keys}" if invalid_keys.any?
 
-        job_class = Class.new do
+        build_job_klass(opts).tap do |klass|
+          klass.const_set(:JOBABLE_OPTS, opts)
+          klass.const_set(:JOBABLE_METHOD_NAME, method_name)
+        end
+      end
+
+      def build_job_klass(opts)
+        Class.new do
           include Sidekiq::Job
 
-          sidekiq_options(this.opts)
+          sidekiq_options(opts)
 
           def perform(...)
             self.class.module_parent.send(self.class::JOBABLE_METHOD_NAME, ...)
           end
         end
-
-        job_class.const_set(:JOBABLE_OPTS, opts)
-        job_class.const_set(:JOBABLE_METHOD_NAME, method_name)
-        job_class
       end
     end
 
-    concerning :AsyncJobClass do
-      def async_job_class
-        klass = Class.new do
-          include Interactor
-          include Interactor::Contracts
-        end
-
-        attach_call(klass)
-        attach_call!(klass)
-
-        klass
-      end
-
-      def args(context)
-        args = context.to_h.stringify_keys
-
-        return args unless container_klass.respond_to?(:contract)
-
-        restrict_to_optional_or_keys_from_contract(args)
-      end
-
-      private
-
-      def attach_call(async_job_class)
-        # e.g. SomeInteractor::AsyncWithSuffix.call(foo: 'bar')
-        async_job_class.send(:define_singleton_method, :call) do |context|
-          call!(context)
-        end
-      end
-
-      def attach_call!(async_job_class)
-        this = self
-
-        # e.g. SomeInteractor::AsyncWithSuffix.call!(foo: 'bar')
-        async_job_class.send(:define_singleton_method, :call!) do |context|
-          # e.g. SomeInteractor::JobWithSuffix
-          job_klass = this.container_klass.const_get("Job#{this.klass_suffix}")
-
-          # e.g. SomeInteractor::JobWithSuffix.perform_async({foo: 'bar'})
-          job_klass.perform_async(this.args(context))
-        end
-      end
-
-      def restrict_to_optional_or_keys_from_contract(args)
-        keys = container_klass
-               .contract
-               .expectations
-               .instance_eval { @terms }
-               .schema
-               .key_map
-               .to_dot_notation
-               .map(&:to_s)
-
-        optional = Array(container_klass.optional_attrs).map(&:to_s)
-        keys += optional
-
-        args.slice(*keys)
-      end
+    def async_job_klass
+      AsyncJobKlass.new(container_klass:, klass_suffix:).async_job_klass
     end
   end
 end

data/lib/interactify/jobable.rb

@@ -1,4 +1,6 @@
-require 'interactify/job_maker'
+# frozen_string_literal: true
+
+require "interactify/job_maker"
 
 module Interactify
   module Jobable
@@ -18,7 +20,7 @@ module Interactify
 
         to_call = defined?(super_klass::Async) ? :interactor_job : :job_calling
 
-        klass.send(to_call, opts: opts, method_name: jobable_method_name)
+        klass.send(to_call, opts:, method_name: jobable_method_name)
         super(klass)
       end
     end
@@ -51,18 +53,18 @@ module Interactify
       # obviously you will need to be aware that later interactors
       # in an interactor chain cannot depend on the result of the async
       # interactor
-      def interactor_job(method_name: :call!, opts: {}, klass_suffix: '')
+      def interactor_job(method_name: :call!, opts: {}, klass_suffix: "")
         job_maker = JobMaker.new(container_klass: self, opts:, method_name:, klass_suffix:)
         # with WhateverInteractor::Job you can perform the interactor as a job
         # from sidekiq
         # e.g. WhateverInteractor::Job.perform_async(...)
-        const_set("Job#{klass_suffix}", job_maker.job_class)
+        const_set("Job#{klass_suffix}", job_maker.job_klass)
 
         # with WhateverInteractor::Async you can call WhateverInteractor::Job
         # in an organizer oro on its oen using normal interactor call call! semantics
         # e.g. WhateverInteractor::Async.call(...)
         #      WhateverInteractor::Async.call!(...)
-        const_set("Async#{klass_suffix}", job_maker.async_job_class)
+        const_set("Async#{klass_suffix}", job_maker.async_job_klass)
       end
 
       # if this was defined in ExampleClass this creates the following class
@@ -80,10 +82,10 @@ module Interactify
       # # the following class is created that you can use to enqueue a job
       # in the sidekiq yaml file
       # ExampleClass::Job.some_method
-      def job_calling(method_name:, opts: {}, klass_suffix: '')
+      def job_calling(method_name:, opts: {}, klass_suffix: "")
         job_maker = JobMaker.new(container_klass: self, opts:, method_name:, klass_suffix:)
 
-        const_set("Job#{klass_suffix}", job_maker.job_class)
+        const_set("Job#{klass_suffix}", job_maker.job_klass)
       end
     end
   end

data/lib/interactify/mismatching_promise_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "interactify/contract_failure"
+
+module Interactify
+  class MismatchingPromiseError < ContractFailure
+    def initialize(interactor, promising, promised_keys)
+      super <<~MESSAGE.chomp
+        #{interactor} does not promise:
+        #{promising.inspect}
+
+        Actual promises are:
+        #{promised_keys.inspect}
+      MESSAGE
+    end
+  end
+end

data/lib/interactify/organizer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "interactify/interactor_wrapper"
+
+module Interactify
+  module Organizer
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def organize(*interactors)
+        wrapped = InteractorWrapper.wrap_many(self, interactors)
+
+        super(*wrapped)
+      end
+    end
+
+    def call
+      self.class.organized.each do |interactor|
+        instance = interactor.new(context)
+
+        instance.instance_variable_set(
+          :@_interactor_called_by_non_bang_method,
+          @_interactor_called_by_non_bang_method
+        )
+
+        instance.tap(&:run!)
+      end
+    end
+  end
+end

data/lib/interactify/promising.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "interactify/mismatching_promise_error"
+
+module Interactify
+  class Promising
+    attr_reader :interactor, :promising
+
+    def self.validate(interactor, *promising)
+      new(interactor, *promising).validate
+
+      interactor
+    end
+
+    def initialize(interactor, *promising)
+      @interactor = interactor
+      @promising = format_keys promising
+    end
+
+    def validate
+      return if promising == promised_keys
+
+      raise MismatchingPromiseError.new(interactor, promising, promised_keys)
+    end
+
+    def promised_keys
+      format_keys interactor.promised_keys
+    end
+
+    def format_keys(keys)
+      Array(keys).compact.map(&:to_sym).sort
+    end
+  end
+end

data/lib/interactify/rspec/matchers.rb

@@ -1,4 +1,6 @@
-require 'interactify/interactor_wiring'
+# frozen_string_literal: true
+
+require "interactify/interactor_wiring"
 
 # Custom matcher that implements expect_inputs
 # e.g.
@@ -6,7 +8,9 @@ require 'interactify/interactor_wiring'
 
 RSpec::Matchers.define :expect_inputs do |*expected_inputs|
   match do |actual|
-    actual_inputs = expected_keys(actual)
+    next false unless actual.respond_to?(:expected_keys)
+
+    actual_inputs = Array(actual.expected_keys)
     @missing_inputs = expected_inputs - actual_inputs
     @extra_inputs = actual_inputs - expected_inputs
 
@@ -19,17 +23,15 @@ RSpec::Matchers.define :expect_inputs do |*expected_inputs|
     message += "\n\textra inputs: #{@extra_inputs}" if @extra_inputs
     message
   end
-
-  def expected_keys(klass)
-    Array(klass.contract.expectations.instance_eval { @terms }.json&.rules&.keys)
-  end
 end
 
 # Custom matcher that implements promise_outputs
 # e.g. expect(described_class).to promise_outputs(:request_logger)
 RSpec::Matchers.define :promise_outputs do |*expected_outputs|
   match do |actual|
-    actual_outputs = promised_keys(actual)
+    next false unless actual.respond_to?(:promised_keys)
+
+    actual_outputs = Array(actual.promised_keys)
     @missing_outputs = expected_outputs - actual_outputs
     @extra_outputs = actual_outputs - expected_outputs
 
@@ -42,10 +44,6 @@ RSpec::Matchers.define :promise_outputs do |*expected_outputs|
     message += "\n\textra outputs: #{@extra_outputs}" if @extra_outputs
     message
   end
-
-  def promised_keys(klass)
-    Array(klass.contract.promises.instance_eval { @terms }.json&.rules&.keys)
-  end
 end
 
 # Custom matcher that implements organize_interactors

data/lib/interactify/unique_klass_name.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Interactify
+  module UniqueKlassName
+    def self.for(namespace, prefix)
+      id = generate_unique_id
+      klass_name = :"#{prefix}#{id}"
+
+      while namespace.const_defined?(klass_name)
+        id = generate_unique_id
+        klass_name = :"#{prefix}#{id}"
+      end
+
+      klass_name.to_sym
+    end
+
+    def self.generate_unique_id
+      rand(10_000)
+    end
+  end
+end

data/lib/interactify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Interactify
-  VERSION = '0.1.0-alpha.1'
+  VERSION = "0.3.0-alpha.1"
 end

data/lib/interactify.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-require 'interactor'
-require 'interactor-contracts'
-require 'rails'
-require 'active_support/all'
+require "interactor"
+require "interactor-contracts"
+require "rails"
+require "active_support/all"
 
-require 'interactify/version'
-require 'interactify/contract_helpers'
-require 'interactify/dsl'
-require 'interactify/interactor_wiring'
+require "interactify/version"
+require "interactify/contract_helpers"
+require "interactify/dsl"
+require "interactify/interactor_wiring"
+require "interactify/promising"
 
 module Interactify
   extend ActiveSupport::Concern
@@ -18,6 +19,12 @@ module Interactify
       Interactify::InteractorWiring.new(root: Interactify.configuration.root, ignore:).validate_app
     end
 
+    def reset
+      @on_contract_breach = nil
+      @before_raise_hook = nil
+      @configuration = nil
+    end
+
     def trigger_contract_breach_hook(...)
       @on_contract_breach&.call(...)
     end
@@ -75,11 +82,34 @@ module Interactify
     interactor_job
   end
 
+  class_methods do
+    def promising(*args)
+      Promising.validate(self, *args)
+    end
+
+    def promised_keys
+      _interactify_extract_keys(contract.promises)
+    end
+
+    def expected_keys
+      _interactify_extract_keys(contract.expectations)
+    end
+
+    private
+
+    # this is the most brittle part of the code, relying on
+    # interactor-contracts internals
+    # so extracted it to here so change is isolated
+    def _interactify_extract_keys(clauses)
+      clauses.instance_eval { @terms }.json&.rules&.keys
+    end
+  end
+
   class Configuration
     attr_writer :root
 
     def root
-      @root ||= Rails.root / 'app'
+      @root ||= Rails.root / "app"
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interactify
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.1
+  version: 0.3.0.pre.alpha.1
 platform: ruby
 authors:
 - Mark Burns
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-26 00:00:00.000000000 Z
+date: 2023-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: interactor
@@ -109,21 +109,32 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/interactify.rb
+- lib/interactify/async_job_klass.rb
 - lib/interactify/call_wrapper.rb
+- lib/interactify/contract_failure.rb
 - lib/interactify/contract_helpers.rb
 - lib/interactify/dsl.rb
 - lib/interactify/each_chain.rb
 - lib/interactify/if_interactor.rb
 - lib/interactify/interactor_wiring.rb
+- lib/interactify/interactor_wiring/callable_representation.rb
+- lib/interactify/interactor_wiring/constants.rb
+- lib/interactify/interactor_wiring/error_context.rb
+- lib/interactify/interactor_wiring/files.rb
+- lib/interactify/interactor_wrapper.rb
 - lib/interactify/job_maker.rb
 - lib/interactify/jobable.rb
-- lib/interactify/organizer_call_monkey_patch.rb
+- lib/interactify/mismatching_promise_error.rb
+- lib/interactify/organizer.rb
+- lib/interactify/promising.rb
 - lib/interactify/rspec/matchers.rb
+- lib/interactify/unique_klass_name.rb
 - lib/interactify/version.rb
 - sig/interactify.rbs
 homepage: https://github.com/markburns/interactify

data/lib/interactify/organizer_call_monkey_patch.rb

@@ -1,40 +0,0 @@
-module Interactify
-  module OrganizerCallMonkeyPatch
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def organize(*interactors)
-        wrapped = wrap_lambdas_in_interactors(interactors)
-
-        super(*wrapped)
-      end
-
-      def wrap_lambdas_in_interactors(interactors)
-        Array(interactors).map do |interactor|
-          case interactor
-          when Proc
-            Class.new do
-              include Interactify
-
-              define_method(:call) do
-                interactor.call(context)
-              end
-            end
-          else
-            interactor
-          end
-        end
-      end
-    end
-
-    def call
-      self.class.organized.each do |interactor|
-        instance = interactor.new(context)
-        instance.instance_variable_set(:@_interactor_called_by_non_bang_method,
-                                       @_interactor_called_by_non_bang_method)
-
-        instance.tap(&:run!)
-      end
-    end
-  end
-end