interactify 0.3.0.pre.alpha.1 → 0.4.0

data/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

data/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

data/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

data/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

data/lib/interactify/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Interactify
+  class Configuration
+    attr_writer :root
+
+    def root
+      @root ||= fallback
+    end
+
+    def fallback
+      Rails.root / "app" if Interactify.railties?
+    end
+  end
+end

data/lib/interactify/contracts/call_wrapper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Interactify
+  module Contracts
+    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
+end

data/lib/interactify/contracts/failure.rb

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

data/lib/interactify/contracts/helpers.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "interactify/async/jobable"
+require "interactify/contracts/call_wrapper"
+require "interactify/contracts/failure"
+require "interactify/contracts/setup"
+require "interactify/dsl/organizer"
+
+module Interactify
+  module Contracts
+    module Helpers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def expect(*attrs, filled: true)
+          Setup.expects(context: self, attrs:, filled:)
+        end
+
+        def promise(*attrs, filled: true, should_delegate: true)
+          Setup.promises(context: self, attrs:, filled:, should_delegate:)
+        end
+
+        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
+
+        def optional(*attrs)
+          @optional_attrs ||= []
+          @optional_attrs += attrs
+
+          delegate(*attrs, to: :context)
+        end
+
+        attr_reader :optional_attrs
+
+        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
+
+      included do
+        c = Class.new(Contracts::Failure)
+        # example self is Whatever::SomeInteractor
+        # failure class:  Whatever::SomeInteractor::InteractorContractFailure
+        const_set "InteractorContractFailure", c
+        prepend Contracts::CallWrapper
+        include Dsl::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
+end

data/lib/interactify/contracts/mismatching_promise_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "interactify/contracts/failure"
+
+module Interactify
+  module Contracts
+    class MismatchingPromiseError < Contracts::Failure
+      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
+end

data/lib/interactify/contracts/promising.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "interactify/contracts/mismatching_promise_error"
+
+module Interactify
+  module Contracts
+    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
+end

data/lib/interactify/contracts/setup.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Interactify
+  module Contracts
+    class Setup
+      def self.expects(context:, attrs:, filled:)
+        new(context:, attrs:, filled:).setup(:expects)
+      end
+
+      def self.promises(context:, attrs:, filled:, should_delegate:)
+        new(context:, attrs:, filled:, should_delegate:).setup(:promises)
+      end
+
+      def initialize(context:, attrs:, filled:, should_delegate: true)
+        @context = context
+        @attrs = attrs
+        @filled = filled
+        @should_delegate = should_delegate
+      end
+
+      def setup(meth)
+        this = self
+
+        @context.send(meth) do
+          this.setup_attrs self
+        end
+
+        @context.delegate(*@attrs, to: :context) if @should_delegate
+      end
+
+      def setup_attrs(contract)
+        @attrs.each do |attr|
+          field = contract.required(attr)
+          field.filled if @filled
+        end
+      end
+    end
+  end
+end

data/lib/interactify/dsl/each_chain.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "interactify/dsl/unique_klass_name"
+
+module Interactify
+  module Dsl
+    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 = Wrapper.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
+end

data/lib/interactify/dsl/if_interactor.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "interactify/dsl/unique_klass_name"
+require "interactify/dsl/if_klass"
+
+module Interactify
+  module Dsl
+    class IfInteractor
+      attr_reader :condition, :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_arg, failure_arg)
+        @evaluating_receiver = evaluating_receiver
+        @condition = condition
+        @success_arg = succcess_arg
+        @failure_arg = failure_arg
+      end
+
+      def success_interactor
+        @success_interactor ||= build_chain(@success_arg, true)
+      end
+
+      def failure_interactor
+        @failure_interactor ||= build_chain(@failure_arg, false)
+      end
+
+      # allows us to dynamically create an interactor chain
+      # that iterates over the packages and
+      # uses the passed in each_loop_klasses
+      def klass
+        IfKlass.new(self).klass
+      end
+
+      # so we have something to attach subclasses to during building
+      # of the outer class, before we finalize the outer If class
+      def klass_basis
+        @klass_basis ||= Class.new do
+          include Interactify
+        end
+      end
+
+      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
+        @if_klass_name ||=
+          begin
+            prefix = condition.is_a?(Proc) ? "Proc" : condition
+            prefix = "If#{prefix.to_s.camelize}"
+
+            UniqueKlassName.for(namespace, prefix)
+          end
+      end
+
+      private
+
+      def build_chain(arg, truthiness)
+        return if arg.nil?
+
+        case arg
+        when Array
+          name = "If#{condition.to_s.camelize}#{truthiness ? 'IsTruthy' : 'IsFalsey'}"
+          klass_basis.chain(name, *arg)
+        else
+          arg
+        end
+      end
+    end
+  end
+end