interactify 0.3.0.pre.RC1 → 0.4.0

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

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-RC1"
+  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
 

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,12 +2,12 @@
 
 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:, ignore: [])