interactify 0.3.0.pre.RC1 → 0.4.0

data/lib/interactify.rb

@@ -5,10 +5,11 @@ require "interactor-contracts"
 require "active_support/all"
 
 require "interactify/version"
-require "interactify/contract_helpers"
+require "interactify/contracts/helpers"
+require "interactify/contracts/promising"
 require "interactify/dsl"
-require "interactify/interactor_wiring"
-require "interactify/promising"
+require "interactify/wiring"
+require "interactify/configuration"
 
 module Interactify
   def self.railties_missing?
@@ -44,6 +45,11 @@ module Interactify
   end
 end
 
+Interactify.instance_eval do
+  @sidekiq_missing = nil
+  @railties_missing = nil
+end
+
 begin
   require "sidekiq"
 rescue LoadError
@@ -51,7 +57,7 @@ rescue LoadError
 end
 
 begin
-  require 'rails/railtie'
+  require "rails/railtie"
 rescue LoadError
   Interactify.railties_missing!
 end
@@ -61,15 +67,7 @@ module Interactify
 
   class << self
     def validate_app(ignore: [])
-      Interactify::InteractorWiring.new(root: Interactify.configuration.root, ignore:).validate_app
-    end
-
-    def sidekiq_missing?
-      @sidekiq_missing
-    end
-
-    def sidekiq_missing!
-      @sidekiq_missing = true
+      Interactify::Wiring.new(root: Interactify.configuration.root, ignore:).validate_app
     end
 
     def reset
@@ -110,7 +108,7 @@ module Interactify
 
     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
@@ -131,45 +129,10 @@ module Interactify
     # 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interactify
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.RC1
+  version: 0.4.0
 platform: ruby
 authors:
 - Mark Burns
@@ -10,34 +10,6 @@ bindir: exe
 cert_chain: []
 date: 2023-12-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: interactor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: interactor-contracts
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -53,13 +25,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 6.0.0
 - !ruby/object:Gem::Dependency
-  name: debug
+  name: interactor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -67,13 +39,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: interactor-contracts
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -116,28 +88,31 @@ files:
 - gemfiles/railties_7_sidekiq.gemfile
 - gemfiles/railties_7_sidekiq.gemfile.lock
 - 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/async/job_klass.rb
+- lib/interactify/async/job_maker.rb
+- lib/interactify/async/jobable.rb
+- lib/interactify/async/null_job.rb
+- lib/interactify/configuration.rb
+- lib/interactify/contracts/call_wrapper.rb
+- lib/interactify/contracts/failure.rb
+- lib/interactify/contracts/helpers.rb
+- lib/interactify/contracts/mismatching_promise_error.rb
+- lib/interactify/contracts/promising.rb
+- lib/interactify/contracts/setup.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/mismatching_promise_error.rb
-- lib/interactify/null_job.rb
-- lib/interactify/organizer.rb
-- lib/interactify/promising.rb
-- lib/interactify/rspec/matchers.rb
-- lib/interactify/unique_klass_name.rb
+- lib/interactify/dsl/each_chain.rb
+- lib/interactify/dsl/if_interactor.rb
+- lib/interactify/dsl/if_klass.rb
+- lib/interactify/dsl/organizer.rb
+- lib/interactify/dsl/unique_klass_name.rb
+- lib/interactify/dsl/wrapper.rb
+- lib/interactify/rspec_matchers/matchers.rb
 - lib/interactify/version.rb
+- lib/interactify/wiring.rb
+- lib/interactify/wiring/callable_representation.rb
+- lib/interactify/wiring/constants.rb
+- lib/interactify/wiring/error_context.rb
+- lib/interactify/wiring/files.rb
 - sig/interactify.rbs
 homepage: https://github.com/markburns/interactify
 licenses:
@@ -156,12 +131,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.8
+      version: 3.1.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.26
 signing_key:

data/lib/interactify/async_job_klass.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Interactify
-  class AsyncJobKlass
-    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

data/lib/interactify/call_wrapper.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Interactify
-  module CallWrapper
-    # https://github.com/collectiveidea/interactor/blob/57b2af9a5a5afeb2c01059c40b792485cc21b052/lib/interactor.rb#L114
-    # Interactor#run calls Interactor#run!
-    # https://github.com/collectiveidea/interactor/blob/57b2af9a5a5afeb2c01059c40b792485cc21b052/lib/interactor.rb#L49
-    # Interactor.call calls Interactor.run
-    #
-    # The non bang methods call the bang methods and rescue
-    def run
-      @_interactor_called_by_non_bang_method = true
-
-      super
-    end
-  end
-end

data/lib/interactify/contract_failure.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Interactify
-  class ContractFailure < ::Interactor::Failure
-  end
-end

data/lib/interactify/contract_helpers.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/jobable"
-require "interactify/call_wrapper"
-require "interactify/organizer"
-require "interactify/contract_failure"
-
-module Interactify
-  module ContractHelpers
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def expect(*attrs, filled: true)
-        expects do
-          attrs.each do |attr|
-            field = required(attr)
-            field.filled if filled
-          end
-        end
-
-        delegate(*attrs, to: :context)
-      end
-
-      def optional(*attrs)
-        @optional_attrs ||= []
-        @optional_attrs += attrs
-
-        delegate(*attrs, to: :context)
-      end
-
-      attr_reader :optional_attrs
-
-      def promise(*attrs, filled: true, should_delegate: true)
-        promises do
-          attrs.each do |attr|
-            field = required(attr)
-            field.filled if filled
-          end
-        end
-
-        delegate(*attrs, to: :context) if should_delegate
-      end
-    end
-
-    included do
-      c = Class.new(ContractFailure)
-      # example self is Whatever::SomeInteractor
-      # failure class:  Whatever::SomeInteractor::InteractorContractFailure
-      const_set "InteractorContractFailure", c
-      prepend CallWrapper
-      include Organizer
-
-      on_breach do |breaches|
-        breaches = breaches.map { |b| { b.property => b.messages } }.inject(&:merge)
-
-        Interactify.trigger_contract_breach_hook(context, breaches)
-
-        if @_interactor_called_by_non_bang_method == true
-          context.fail! contract_failures: breaches
-        else
-          # e.g. raises
-          # SomeNamespace::SomeClass::ContractFailure, {whatever: 'is missing'}
-          # but also sending the context into Sentry
-          exception = c.new(breaches.to_json)
-          Interactify.trigger_before_raise_hook(exception)
-          raise exception
-        end
-      end
-    end
-  end
-end

data/lib/interactify/each_chain.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/unique_klass_name"
-
-module Interactify
-  class EachChain
-    attr_reader :each_loop_klasses, :plural_resource_name, :evaluating_receiver
-
-    def self.attach_klass(evaluating_receiver, plural_resource_name, *each_loop_klasses)
-      iteratable = new(each_loop_klasses, plural_resource_name, evaluating_receiver)
-      iteratable.attach_klass
-    end
-
-    def initialize(each_loop_klasses, plural_resource_name, evaluating_receiver)
-      @each_loop_klasses = each_loop_klasses
-      @plural_resource_name = plural_resource_name
-      @evaluating_receiver = evaluating_receiver
-    end
-
-    # allows us to dynamically create an interactor chain
-    # that iterates over the packages and
-    # uses the passed in each_loop_klasses
-    # rubocop:disable all
-    def klass
-      this = self
-
-      Class.new do                                                                    # class SomeNamespace::EachPackage
-        include Interactify                                          #   include Interactify
-
-        expects do                                                                    #   expects do
-          required(this.plural_resource_name)                                         #     required(:packages)
-        end                                                                           #   end
-
-        define_singleton_method(:source_location) do                                  #   def self.source_location
-          const_source_location this.evaluating_receiver.to_s                                     #     [file, line]
-        end                                                                           #   end
-
-        define_method(:run!) do                                                       #  def run!
-          context.send(this.plural_resource_name).each_with_index do |resource, index|#    context.packages.each_with_index do |package, index|
-            context[this.singular_resource_name] = resource                           #       context.package = package
-            context[this.singular_resource_index_name] = index                        #       context.package_index = index
-
-            klasses = InteractorWrapper.wrap_many(self, this.each_loop_klasses)
-
-            klasses.each do |interactor|                                              #       [A, B, C].each do |interactor|
-              interactor.call!(context)                                               #         interactor.call!(context)
-            end                                                                       #       end
-          end                                                                         #     end
-
-          context[this.singular_resource_name] = nil                                  #     context.package = nil
-          context[this.singular_resource_index_name] = nil                            #     context.package_index = nil
-
-          context                                                                     #     context
-        end                                                                           #   end
-
-        define_method(:inspect) do
-          "<#{this.namespace}::#{this.iterator_klass_name} iterates_over: #{this.each_loop_klasses.inspect}>"
-        end
-      end
-    end
-    # rubocop:enable all
-
-    def attach_klass
-      name = iterator_klass_name
-
-      namespace.const_set(name, klass)
-      namespace.const_get(name)
-    end
-
-    def namespace
-      evaluating_receiver
-    end
-
-    def iterator_klass_name
-      prefix = "Each#{singular_resource_name.to_s.camelize}"
-
-      UniqueKlassName.for(namespace, prefix)
-    end
-
-    def singular_resource_name
-      plural_resource_name.to_s.singularize.to_sym
-    end
-
-    def singular_resource_index_name
-      "#{singular_resource_name}_index".to_sym
-    end
-  end
-end

data/lib/interactify/if_interactor.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/unique_klass_name"
-
-module Interactify
-  class IfInteractor
-    attr_reader :condition, :success_interactor, :failure_interactor, :evaluating_receiver
-
-    def self.attach_klass(evaluating_receiver, condition, succcess_interactor, failure_interactor)
-      ifable = new(evaluating_receiver, condition, succcess_interactor, failure_interactor)
-      ifable.attach_klass
-    end
-
-    def initialize(evaluating_receiver, condition, succcess_interactor, failure_interactor)
-      @evaluating_receiver = evaluating_receiver
-      @condition = condition
-      @success_interactor = succcess_interactor
-      @failure_interactor = failure_interactor
-    end
-
-    # allows us to dynamically create an interactor chain
-    # that iterates over the packages and
-    # uses the passed in each_loop_klasses
-    # rubocop:disable all
-    def klass
-      this = self
-
-      Class.new do                                                           
-        include Interactor                                                    
-        include Interactor::Contracts                                          
-
-        expects do                                                              
-          required(this.condition) unless this.condition.is_a?(Proc)
-        end                                                                       
-
-        define_singleton_method(:source_location) do                               
-          const_source_location this.evaluating_receiver.to_s                                     #     [file, line]
-        end                                                                          
-
-        define_method(:run!) do                                                       
-          result = this.condition.is_a?(Proc) ? this.condition.call(context) : context.send(this.condition)
-          interactor = result ? this.success_interactor : this.failure_interactor
-          interactor&.respond_to?(:call!) ? interactor.call!(context) : interactor&.call(context)
-        end
-
-        define_method(:inspect) do
-          "<#{this.namespace}::#{this.if_klass_name} #{this.condition} ? #{this.success_interactor} : #{this.failure_interactor}>"
-        end
-      end
-    end
-    # rubocop:enable all
-
-    def attach_klass
-      name = if_klass_name
-      namespace.const_set(name, klass)
-      namespace.const_get(name)
-    end
-
-    def namespace
-      evaluating_receiver
-    end
-
-    def if_klass_name
-      prefix = condition.is_a?(Proc) ? "Proc" : condition
-      prefix = "If#{prefix.to_s.camelize}"
-
-      UniqueKlassName.for(namespace, prefix)
-    end
-  end
-end

data/lib/interactify/interactor_wrapper.rb

@@ -1,72 +0,0 @@
-# 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,56 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/async_job_klass"
-require "interactify/null_job"
-
-module Interactify
-  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
-      AsyncJobKlass.new(container_klass:, klass_suffix:).async_job_klass
-    end
-  end
-end