interactify 0.3.0.pre.alpha.1 → 0.4.0

data/lib/interactify/dsl/if_klass.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Interactify
+  module Dsl
+    class IfKlass
+      attr_reader :if_builder
+
+      def initialize(if_builder)
+        @if_builder = if_builder
+      end
+
+      def klass
+        attach_expectations
+        attach_source_location
+        attach_run!
+        attach_inspect
+
+        if_builder.klass_basis
+      end
+
+      def run!(context)
+        result = condition.is_a?(Proc) ? condition.call(context) : context.send(condition)
+
+        interactor = result ? success_interactor : failure_interactor
+        interactor.respond_to?(:call!) ? interactor.call!(context) : interactor&.call(context)
+      end
+
+      private
+
+      def attach_source_location
+        attach do |_klass, this|
+          define_singleton_method(:source_location) do            #   def self.source_location
+            const_source_location this.evaluating_receiver.to_s   #     [file, line]
+          end
+        end
+      end
+
+      def attach_expectations
+        attach do |klass, this|
+          klass.expects do
+            required(this.condition) unless this.condition.is_a?(Proc)
+          end
+        end
+      end
+
+      def attach_run!
+        this = self
+
+        attach_method(:run!) do
+          this.run!(context)
+        end
+      end
+
+      delegate :condition, :success_interactor, :failure_interactor, to: :if_builder
+
+      def attach_inspect
+        this = if_builder
+
+        attach_method(:inspect) do
+          name = "#{this.namespace}::#{this.if_klass_name}"
+          "<#{name} #{this.condition} ? #{this.success_interactor} : #{this.failure_interactor}>"
+        end
+      end
+
+      # rubocop: disable Naming/BlockForwarding
+      def attach_method(name, &block)
+        attach do |klass, _this|
+          klass.define_method(name, &block)
+        end
+      end
+      # rubocop: enable Naming/BlockForwarding
+
+      def attach
+        this = if_builder
+
+        this.klass_basis.instance_eval do
+          yield self, this
+        end
+      end
+    end
+  end
+end

data/lib/interactify/dsl/organizer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "interactify/dsl/wrapper"
+
+module Interactify
+  module Dsl
+    module Organizer
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def organize(*interactors)
+          wrapped = Wrapper.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
+end

data/lib/interactify/dsl/unique_klass_name.rb

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

data/lib/interactify/dsl/wrapper.rb

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

data/lib/interactify/dsl.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "interactify/each_chain"
-require "interactify/if_interactor"
-require "interactify/unique_klass_name"
+require "interactify/dsl/each_chain"
+require "interactify/dsl/if_interactor"
+require "interactify/dsl/unique_klass_name"
 
 module Interactify
   module Dsl
@@ -22,12 +22,18 @@ module Interactify
       )
     end
 
-    def if(condition, succcess_interactor, failure_interactor = nil)
+    def if(condition, success_arg, failure_arg = nil)
+      then_else = if success_arg.is_a?(Hash) && failure_arg.nil?
+                    success_arg.slice(:then, :else)
+                  else
+                    { then: success_arg, else: failure_arg }
+                  end
+
       IfInteractor.attach_klass(
         self,
         condition,
-        succcess_interactor,
-        failure_interactor
+        then_else[:then],
+        then_else[:else]
       )
     end
 

data/lib/interactify/rspec_matchers/matchers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "interactify/wiring"
+
+module Interactify
+  module RSpecMatchers
+    class ContractMatcher
+      attr_reader :actual, :expected_values, :actual_values, :type
+
+      def initialize(actual, expected_values, actual_values, type)
+        @actual = actual
+        @expected_values = expected_values
+        @actual_values = actual_values
+        @type = type
+      end
+
+      def failure_message
+        message = "expected #{actual} to #{type} #{expected_values.inspect}"
+        message += "\n\tmissing: #{missing}" if missing.any?
+        message += "\n\textra: #{extra}" if extra.any?
+        message
+      end
+
+      def valid?
+        missing.empty? && extra.empty?
+      end
+
+      def missing
+        expected_values - actual_values
+      end
+
+      def extra
+        actual_values - expected_values
+      end
+    end
+  end
+end
+
+# Custom matchers that implement expect_inputs, promise_outputs, organize_interactors
+# e.g. expect(described_class).to expect_inputs(:connection, :order)
+# e.g. expect(described_class).to promise_outputs(:request_logger)
+# e.g. expect(described_class).to organize_interactors(SeparateIntoPackages, SendPackagesToSeko)
+[
+  %i[expect_inputs expected_keys],
+  %i[promise_outputs promised_keys],
+  %i[organize_interactors organized]
+].each do |type, meth|
+  RSpec::Matchers.define type do |*expected_values|
+    match do |actual|
+      next false unless actual.respond_to?(meth)
+
+      actual_values = Array(actual.send(meth))
+
+      @contract_matcher = Interactify::RSpecMatchers::ContractMatcher.new(
+        actual,
+        expected_values,
+        actual_values,
+        type.to_s.gsub("_", " ")
+      )
+
+      @contract_matcher.valid?
+    end
+
+    failure_message do
+      @contract_matcher.failure_message
+    end
+  end
+end

data/lib/interactify/version.rb

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

data/lib/interactify/{interactor_wiring → wiring}/callable_representation.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "interactify/interactor_wiring/error_context"
+require "interactify/wiring/error_context"
 
 module Interactify
-  class InteractorWiring
+  class Wiring
     class CallableRepresentation
       attr_reader :filename, :klass, :wiring
 

data/lib/interactify/{interactor_wiring → wiring}/constants.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Interactify
-  class InteractorWiring
+  class Wiring
     class Constants
       attr_reader :root, :organizer_files, :interactor_files
 
@@ -67,7 +67,7 @@ module Interactify
 
       def interactor_klass?(object)
         return unless object.is_a?(Class) && object.ancestors.include?(Interactor)
-        return if object.is_a?(Sidekiq::Job)
+        return if Interactify.sidekiq? && object.is_a?(Sidekiq::Job)
 
         true
       end
@@ -116,9 +116,9 @@ module Interactify
                 .gsub(root.to_s, "")   # "/namespace/sub_namespace/class_name.rb"
                 .gsub("/concerns", "") #  concerns directory is ignored by Zeitwerk
                 .split("/")            # "['', 'namespace', 'sub_namespace', 'class_name.rb']
-                .compact_blank         # "['namespace', 'sub_namespace', 'class_name.rb']
+                .reject(&:blank?)      # "['namespace', 'sub_namespace', 'class_name.rb']
                 .join("/")             # 'namespace/sub_namespace/class_name.rb'
-                .gsub(/\.rb\z/, "")     # 'namespace/sub_namespace/class_name'
+                .gsub(/\.rb\z/, "")    # 'namespace/sub_namespace/class_name'
       end
     end
   end

data/lib/interactify/{interactor_wiring → wiring}/error_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Interactify
-  class InteractorWiring
+  class Wiring
     class ErrorContext
       def previously_defined_keys
         @previously_defined_keys ||= Set.new

data/lib/interactify/{interactor_wiring → wiring}/files.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Interactify
-  class InteractorWiring
+  class Wiring
     class Files
       attr_reader :root
 

data/lib/interactify/{interactor_wiring.rb → wiring.rb}

@@ -2,15 +2,15 @@
 
 require "active_support/all"
 
-require "interactify/interactor_wiring/callable_representation"
-require "interactify/interactor_wiring/constants"
-require "interactify/interactor_wiring/files"
+require "interactify/wiring/callable_representation"
+require "interactify/wiring/constants"
+require "interactify/wiring/files"
 
 module Interactify
-  class InteractorWiring
+  class Wiring
     attr_reader :root, :ignore
 
-    def initialize(root: Rails.root, ignore: [])
+    def initialize(root:, ignore: [])
       @root = root.to_s.gsub(%r{/$}, "")
       @ignore = ignore
     end

data/lib/interactify.rb

@@ -2,21 +2,72 @@
 
 require "interactor"
 require "interactor-contracts"
-require "rails"
 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?
+    @railties_missing
+  end
+
+  def self.railties_missing!
+    @railties_missing = true
+  end
+
+  def self.railties
+    railties?
+  end
+
+  def self.railties?
+    !railties_missing?
+  end
+
+  def self.sidekiq_missing?
+    @sidekiq_missing
+  end
+
+  def self.sidekiq_missing!
+    @sidekiq_missing = true
+  end
+
+  def self.sidekiq
+    sidekiq?
+  end
+
+  def self.sidekiq?
+    !sidekiq_missing?
+  end
+end
+
+Interactify.instance_eval do
+  @sidekiq_missing = nil
+  @railties_missing = nil
+end
+
+begin
+  require "sidekiq"
+rescue LoadError
+  Interactify.sidekiq_missing!
+end
+
+begin
+  require "rails/railtie"
+rescue LoadError
+  Interactify.railties_missing!
+end
 
 module Interactify
   extend ActiveSupport::Concern
 
   class << self
     def validate_app(ignore: [])
-      Interactify::InteractorWiring.new(root: Interactify.configuration.root, ignore:).validate_app
+      Interactify::Wiring.new(root: Interactify.configuration.root, ignore:).validate_app
     end
 
     def reset
@@ -57,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
@@ -78,41 +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 ||= Rails.root / "app"
-    end
-  end
-
   def called_klass_list
     context._called.map(&:class)
   end