move into Dsl/Async/Contracts namespaces (#15)

* move into Dsl/Async/Contracts namespaces

* fix constant name

Author: markburns

README.md

@@ -312,7 +312,7 @@ In order to detect these wiring issues, stick a spec in your test suite like thi
 ```ruby
 RSpec.describe 'InteractorWiring' do
   it 'validates the interactors in the whole app', :aggregate_failures do
-    errors = Interactify.validate_app(ignore: [/Priam/])
+    errors = Interactify.validate_app(ignore: [/SomeClassName/, AnotherClass, 'SomeClassNameString'])
 
     expect(errors).to eq ''
   end

lib/interactify.rb

@@ -5,10 +5,11 @@
 require "active_support/all"
 
 require "interactify/version"
-require "interactify/contract_helpers"
+require "interactify/contracts/helpers"
+require "interactify/contracts/promising"
 require "interactify/dsl"
 require "interactify/wiring"
-require "interactify/promising"
+require "interactify/configuration"
 
 module Interactify
   def self.railties_missing?
@@ -102,7 +103,7 @@ def configuration
 
     base.include Interactor::Organizer
     base.include Interactor::Contracts
-    base.include Interactify::ContractHelpers
+    base.include Interactify::Contracts::Helpers
 
     # defines two classes on the receiver class
     # the first is the job class
@@ -123,45 +124,10 @@ def configuration
     # that calls the interactor ExampleInteractor with (foo: 'bar')
     #
     # ExampleInteractor::Async.call(foo: 'bar')
-    include Interactify::Jobable
+    include Interactify::Async::Jobable
     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 ||= fallback
-    end
-
-    def fallback
-      Rails.root / "app" if Interactify.railties?
-    end
-  end
-
   def called_klass_list
     context._called.map(&:class)
   end

lib/interactify/async/job_klass.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Interactify
+  module Async
+    class JobKlass
+      attr_reader :container_klass, :klass_suffix
+
+      def initialize(container_klass:, klass_suffix:)
+        @container_klass = container_klass
+        @klass_suffix = klass_suffix
+      end
+
+      def async_job_klass
+        klass = Class.new do
+          include Interactor
+          include Interactor::Contracts
+        end
+
+        attach_call(klass)
+        attach_call!(klass)
+
+        klass
+      end
+
+      def attach_call(async_job_klass)
+        # e.g. SomeInteractor::AsyncWithSuffix.call(foo: 'bar')
+        async_job_klass.send(:define_singleton_method, :call) do |context|
+          call!(context)
+        end
+      end
+
+      def attach_call!(async_job_klass)
+        this = self
+
+        # e.g. SomeInteractor::AsyncWithSuffix.call!(foo: 'bar')
+        async_job_klass.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 args(context)
+        args = context.to_h.stringify_keys
+
+        return args unless container_klass.respond_to?(:expected_keys)
+
+        restrict_to_optional_or_keys_from_contract(args)
+      end
+
+      def restrict_to_optional_or_keys_from_contract(args)
+        keys = container_klass.expected_keys.map(&:to_s)
+
+        optional = Array(container_klass.optional_attrs).map(&:to_s)
+        keys += optional
+
+        args.slice(*keys)
+      end
+    end
+  end
+end

lib/interactify/async/job_maker.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "interactify/async/job_klass"
+require "interactify/async/null_job"
+
+module Interactify
+  module Async
+    class JobMaker
+      attr_reader :opts, :method_name, :container_klass, :klass_suffix
+
+      def initialize(container_klass:, opts:, klass_suffix:, method_name: :call!)
+        @container_klass = container_klass
+        @opts = opts
+        @method_name = method_name
+        @klass_suffix = klass_suffix
+      end
+
+      concerning :JobClass do
+        def job_klass
+          @job_klass ||= define_job_klass
+        end
+
+        private
+
+        def define_job_klass
+          return NullJob if Interactify.sidekiq_missing?
+
+          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?
+
+          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(opts)
+
+            def perform(...)
+              self.class.module_parent.send(self.class::JOBABLE_METHOD_NAME, ...)
+            end
+          end
+        end
+      end
+
+      def async_job_klass
+        JobKlass.new(container_klass:, klass_suffix:).async_job_klass
+      end
+    end
+  end
+end

lib/interactify/async/jobable.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "interactify/async/job_maker"
+
+module Interactify
+  module Async
+    module Jobable
+      extend ActiveSupport::Concern
+
+      # e.g. if Klass < Base
+      # and Base has a Base::Job class
+      #
+      # then let's make sure to define Klass::Job separately
+      included do |base|
+        next if Interactify.sidekiq_missing?
+
+        def base.inherited(klass)
+          super_klass = klass.superclass
+          super_job = super_klass::Job # really spiffing
+
+          opts = super_job::JOBABLE_OPTS
+          jobable_method_name = super_job::JOBABLE_METHOD_NAME
+
+          to_call = defined?(super_klass::Async) ? :interactor_job : :job_calling
+
+          klass.send(to_call, opts:, method_name: jobable_method_name)
+          super(klass)
+        end
+      end
+
+      class_methods do
+        # create a Job class and an Async class
+        # see job_calling for details on the Job class
+        #
+        # the Async class is a wrapper around the Job class
+        # that allows it to be used in an interactor chain
+        #
+        # E.g.
+        #
+        # class ExampleInteractor
+        #   include Interactify
+        #   expect :foo
+        #
+        #   include Jobable
+        #   interactor_job
+        # end
+        #
+        # doing the following will immediately enqueue a job
+        # that calls the interactor ExampleInteractor with (foo: 'bar')
+        # ExampleInteractor::Async.call(foo: 'bar')
+        #
+        # it will also ensure to pluck only the expects from the context
+        # so that you can have other non primitive values in the context
+        # but the job will only have the expects passed to it
+        #
+        # 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: "")
+          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_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_klass)
+        end
+
+        # if this was defined in ExampleClass this creates the following class
+        # ExampleClass::Job
+        # this class ia added as a convenience so you can easily turn a
+        # class method into a job
+        #
+        # Example:
+        #
+        # class ExampleClass
+        #   include Jobable
+        #   job_calling method_name: :some_method
+        # end
+        #
+        # # 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: "")
+          job_maker = JobMaker.new(container_klass: self, opts:, method_name:, klass_suffix:)
+
+          const_set("Job#{klass_suffix}", job_maker.job_klass)
+        end
+      end
+    end
+  end
+end

lib/interactify/async/null_job.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Interactify
+  module Async
+    class NullJob
+      def method_missing(...)
+        self
+      end
+
+      def self.method_missing(...)
+        self
+      end
+
+      def respond_to_missing?(...)
+        true
+      end
+
+      def self.respond_to_missing?(...)
+        true
+      end
+    end
+  end
+end