interactify 0.1.0.pre.alpha.1 → 0.2.0.pre.alpha.1

data/lib/interactify/interactor_wiring/error_context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Interactify
+  class InteractorWiring
+    class ErrorContext
+      def previously_defined_keys
+        @previously_defined_keys ||= Set.new
+      end
+
+      def append_previously_defined_keys(keys)
+        keys.each do |key|
+          previously_defined_keys << key
+        end
+      end
+
+      def missing_keys
+        @missing_keys ||= {}
+      end
+
+      def add_promised_keys(promised_keys)
+        promised_keys.each do |key|
+          previously_defined_keys << key
+        end
+      end
+
+      def infer_missing_keys(callable)
+        new_keys = callable.expected_keys
+        not_in_previous_keys = new_keys.reject { |key| previously_defined_keys.include?(key) }
+
+        add_missing_keys(callable, not_in_previous_keys)
+      end
+
+      def add_missing_keys(callable, not_in_previous_keys)
+        return if not_in_previous_keys.empty?
+
+        missing_keys[callable] ||= Set.new
+        missing_keys[callable] += not_in_previous_keys
+      end
+    end
+  end
+end

data/lib/interactify/interactor_wiring/files.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Interactify
+  class InteractorWiring
+    class Files
+      attr_reader :root
+
+      def initialize(root:)
+        @root = root
+      end
+
+      def organizer_files
+        possible_files.select { |_, contents| organizer_file?(contents) }.map(&:first).sort
+      end
+
+      def interactor_files
+        possible_files.select { |_, contents| interactor_file?(contents) }.map(&:first).sort
+      end
+
+      private
+
+      def organizer_file?(code)
+        organizer?(code) && (interactified?(code) || vanilla_organizer?(code))
+      end
+
+      def interactor_file?(code)
+        !organizer?(code) && (interactified?(code) || vanilla_interactor?(code))
+      end
+
+      def vanilla_organizer?(code)
+        code[/include Interactor::Organizer/]
+      end
+
+      def vanilla_interactor?(code)
+        code[/include Interactor$/]
+      end
+
+      def interactified?(code)
+        code["include Interactify"]
+      end
+
+      def organizer?(code)
+        code[/^\s+organize/]
+      end
+
+      def possible_files
+        @possible_files ||= Dir.glob("#{root}/**/*.rb").map { |f| [f, File.read(f)] }
+      end
+    end
+  end
+end

data/lib/interactify/interactor_wiring.rb

@@ -1,305 +1,90 @@
-require 'active_support/all'
+# frozen_string_literal: true
+
+require "active_support/all"
+
+require "interactify/interactor_wiring/callable_representation"
+require "interactify/interactor_wiring/constants"
+require "interactify/interactor_wiring/files"
 
 module Interactify
   class InteractorWiring
-    attr_reader :root, :namespace, :ignore
+    attr_reader :root, :ignore
 
-    def initialize(root: Rails.root, namespace: 'Object', ignore: [])
-      @root = root.to_s.gsub(%r{/$}, '')
-      @namespace = namespace
+    def initialize(root: Rails.root, ignore: [])
+      @root = root.to_s.gsub(%r{/$}, "")
       @ignore = ignore
     end
 
-    concerning :Validation do
-      def validate_app
-        errors = organizers.each_with_object({}) do |organizer, all_errors|
-          next if ignore_klass?(ignore, organizer.klass)
-
-          errors = organizer.validate_callable
-          all_errors[organizer] = errors
-        end
+    def validate_app
+      errors = organizers.each_with_object({}) do |organizer, all_errors|
+        next if ignore_klass?(ignore, organizer.klass)
 
-        format_errors(errors)
+        errors = organizer.validate_callable
+        all_errors[organizer] = errors
       end
 
-      def format_errors(all_errors)
-        formatted_errors = []
-
-        all_errors.each do |organizer, error_context|
-          next if ignore_klass?(ignore, organizer.klass)
-
-          error_context.missing_keys.each do |interactor, missing|
-            next if ignore_klass?(ignore, interactor.klass)
-
-            formatted_errors << <<~ERROR
-              Missing keys: #{missing.to_a.map(&:to_sym).map(&:inspect).join(', ')}
-                        in: #{interactor.klass}
-                       for: #{organizer.klass}
-            ERROR
-          end
-        end
-
-        formatted_errors.join("\n\n")
-      end
-
-      def ignore_klass?(ignore, klass)
-        case ignore
-        when Array
-          ignore.any? { ignore_klass?(_1, klass) }
-        when Regexp
-          klass.to_s =~ ignore
-        when String
-          klass.to_s[ignore]
-        when Proc
-          ignore.call(klass)
-        when Class
-          klass <= ignore
-        end
-      end
+      format_errors(errors)
     end
 
-    class CallableRepresentation
-      attr_reader :filename, :klass, :wiring
+    def format_errors(all_errors)
+      formatted_errors = []
 
-      delegate :interactor_lookup, to: :wiring
-
-      def initialize(filename:, klass:, wiring:, organizer: nil)
-        @filename = filename
-        @klass = klass
-        @wiring = wiring
-      end
-
-      def validate_callable(error_context: ErrorContext.new)
-        if organizer?
-          assign_previously_defined(error_context: error_context)
-          validate_children(error_context: error_context)
-        end
-
-        validate_self(error_context: error_context)
-      end
-
-      def promised_keys
-        Array(klass.contract.promises.instance_eval { @terms }.json&.rules&.keys)
-      end
-
-      def expected_keys
-        Array(klass.contract.expectations.instance_eval { @terms }.json&.rules&.keys)
+      each_error(all_errors) do |missing, interactor, organizer|
+        format_error(missing, interactor, organizer, formatted_errors)
       end
 
-      def all_keys
-        expected_keys.concat(promised_keys)
-      end
-
-      def inspect
-        "#<#{self.class.name}#{object_id} @filename=#{filename}, @klass=#{klass.name}>"
-      end
-
-      def organizer?
-        klass.respond_to?(:organized)
-      end
-
-      def assign_previously_defined(error_context:)
-        return unless contract?
-
-        error_context.append_previously_defined_keys(all_keys)
-      end
-
-      def validate_children(error_context:)
-        klass.organized.each do |interactor|
-          nested_callable = interactor_lookup[interactor]
-          next if nested_callable.nil?
-
-          error_context = nested_callable.validate_callable(error_context: error_context)
-        end
-
-        error_context
-      end
-
-      private
-
-      def contract?
-        klass.ancestors.include? Interactor::Contracts
-      end
-
-      def validate_self(error_context:)
-        return error_context unless contract?
-
-        error_context.infer_missing_keys(self)
-        error_context.add_promised_keys(promised_keys)
-        error_context
-      end
+      formatted_errors.join("\n\n")
     end
 
-    class ErrorContext
-      def previously_defined_keys
-        @previously_defined_keys ||= Set.new
-      end
-
-      def append_previously_defined_keys(keys)
-        keys.each do |key|
-          previously_defined_keys << key
-        end
-      end
+    def each_error(all_errors)
+      all_errors.each do |organizer, error_context|
+        next if ignore_klass?(ignore, organizer.klass)
 
-      def missing_keys
-        @missing_keys ||= {}
-      end
+        error_context.missing_keys.each do |interactor, missing|
+          next if ignore_klass?(ignore, interactor.klass)
 
-      def add_promised_keys(promised_keys)
-        promised_keys.each do |key|
-          previously_defined_keys << key
+          yield missing, interactor, organizer
         end
       end
-
-      def infer_missing_keys(callable)
-        new_keys = callable.expected_keys
-        not_in_previous_keys = new_keys.reject { |key| previously_defined_keys.include?(key) }
-
-        add_missing_keys(callable, not_in_previous_keys)
-      end
-
-      def add_missing_keys(callable, not_in_previous_keys)
-        return if not_in_previous_keys.empty?
-
-        missing_keys[callable] ||= Set.new
-        missing_keys[callable] += not_in_previous_keys
-      end
     end
 
-    concerning :Constants do
-      def organizers
-        @organizers ||= organizer_files.flat_map do |f|
-          next if f[/interactor_organizer_contracts/] || f[/interactor_contracts/]
-
-          callables_in_file(f)
-        end.compact.select(&:organizer?)
-      end
-
-      def interactors
-        @interactors ||= interactor_files.flat_map do |f|
-          callables_in_file(f)
-        end.compact.reject(&:organizer?)
-      end
-
-      def callables_in_file(f)
-        @callables_in_file ||= {}
-
-        @callables_in_file[f] ||= _callables_in_file(f)
-      end
-
-      def _callables_in_file(f)
-        constant = constant_for(f)
-        return if constant == Interactify
-
-        internal_klasses = internal_constants_for(constant)
-
-        ([constant] + internal_klasses).map { |k| new_callable(f, k, self) }
-      end
-
-      def internal_constants_for(constant)
-        constant
-          .constants
-          .map { |sym| constant_from_symbol(constant, sym) }
-          .select { |pk| interactor_klass?(pk) }
-      end
-
-      def constant_from_symbol(constant, symbol)
-        constant.module_eval do
-          symbol.to_s.constantize
-        rescue StandardError
-          "#{constant.name}::#{symbol}".constantize rescue nil
-        end
-      end
-
-      def interactor_klass?(object)
-        return unless object.is_a? Class
-
-        object.ancestors.include?(Interactor) || object.ancestors.include?(Interactor::Organizer)
-      end
-
-      def new_callable(filename, klass, wiring)
-        CallableRepresentation.new(filename: filename, klass: klass, wiring: wiring)
-      end
-
-      def interactor_lookup
-        @interactor_lookup ||= (interactors + organizers).index_by(&:klass)
-      end
-
-      private
-
-      def constant_for(filename)
-        require filename
-
-        underscored_klass_name = underscored_klass_name_without_outer_namespace(filename)
-        underscored_klass_name = trim_rails_folder underscored_klass_name
-
-        klass_name = underscored_klass_name.classify
-
-        should_pluralize = filename[underscored_klass_name.pluralize]
-        klass_name = klass_name.pluralize if should_pluralize
-
-        outer_namespace_constant.const_get(klass_name)
-      end
-
-      # Example:
-      # trim_rails_folder("interactors/namespace/sub_namespace/class_name.rb")
-      # => "namespace/sub_namespace/class_name.rb"
-      def trim_rails_folder(filename)
-        rails_folders = Dir.glob(Interactify.root / '*').map { |f| File.basename(f) }
-
-        rails_folders.each do |folder|
-          regexable_folder = Regexp.quote("#{folder}/")
-          regex = /^#{regexable_folder}/
-
-          return filename.gsub(regex, '') if filename.match?(regex)
-        end
-
-        filename
-      end
-
-      # Example:
-      # "/home/code/something/app/interactors/namespace/sub_namespace/class_name.rb"
-      # "/namespace/sub_namespace/class_name.rb"
-      #  ['', 'namespace', 'sub_namespace', 'class_name.rb']
-      #  ['namespace', 'sub_namespace', 'class_name.rb']
-      # remove outernamespace (SpecSupport)
-      def underscored_klass_name_without_outer_namespace(filename)
-        filename.to_s # "/home/code/something/app/interactors/namespace/sub_namespace/class_name.rb"
-          .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.with_index { |segment, i| i.zero? && segment == namespace }
-          .join('/')             # 'namespace/sub_namespace/class_name.rb'
-          .gsub(/\.rb\z/, '')     # 'namespace/sub_namespace/class_name'
-      end
-
-      def outer_namespace_constant
-        @outer_namespace_constant ||= Object.const_get(namespace)
-      end
+    def format_error(missing, interactor, organizer, formatted_errors)
+      formatted_errors << <<~ERROR
+        Missing keys: #{missing.to_a.map(&:to_sym).map(&:inspect).join(', ')}
+         expected in: #{interactor.klass}
+           called by: #{organizer.klass}
+      ERROR
     end
 
-    concerning :Files do
-      def organizer_files
-        possible_files.select { |_, contents| organizer_file?(contents) }.map(&:first).sort
+    def ignore_klass?(ignore, klass)
+      case ignore
+      when Array
+        ignore.any? { ignore_klass?(_1, klass) }
+      when Regexp
+        klass.to_s =~ ignore
+      when String
+        klass.to_s[ignore]
+      when Proc
+        ignore.call(klass)
+      when Class
+        klass <= ignore
       end
+    end
 
-      def interactor_files
-        possible_files.select { |_, contents| interactor_file?(contents) }.map(&:first).sort
-      end
+    delegate :organizers, :interactors, :interactor_lookup, to: :constants
 
-      def organizer_file?(file_contents)
-        (file_contents['include Interactify'] || file_contents[/include Interactor::Organizer/]) &&
-          file_contents[/^\s+organize/]
-      end
+    def constants
+      @constants ||= Constants.new(
+        root:,
+        organizer_files:,
+        interactor_files:
+      )
+    end
 
-      def interactor_file?(file_contents)
-        file_contents['include Interactify'] || file_contents[/include Interactor$/]
-      end
+    delegate :organizer_files, :interactor_files, to: :files
 
-      def possible_files
-        @possible_files ||= Dir.glob("#{root}/**/*.rb").map { |f| [f, File.read(f)] }
-      end
+    def files
+      @files ||= Files.new(root:)
     end
   end
 end

data/lib/interactify/job_maker.rb

@@ -1,5 +1,9 @@
-require 'sidekiq'
-require 'sidekiq/job'
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/job"
+
+require "interactify/async_job_klass"
 
 module Interactify
   class JobMaker
@@ -13,93 +17,40 @@ module Interactify
     end
 
     concerning :JobClass do
-      def job_class
-        @job_class ||= define_job_class
+      def job_klass
+        @job_klass ||= define_job_klass
       end
 
       private
 
-      def define_job_class
+      def define_job_klass
         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?
 
-        job_class = Class.new do
+        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(this.opts)
+          sidekiq_options(opts)
 
           def perform(...)
             self.class.module_parent.send(self.class::JOBABLE_METHOD_NAME, ...)
           end
         end
-
-        job_class.const_set(:JOBABLE_OPTS, opts)
-        job_class.const_set(:JOBABLE_METHOD_NAME, method_name)
-        job_class
       end
     end
 
-    concerning :AsyncJobClass do
-      def async_job_class
-        klass = Class.new do
-          include Interactor
-          include Interactor::Contracts
-        end
-
-        attach_call(klass)
-        attach_call!(klass)
-
-        klass
-      end
-
-      def args(context)
-        args = context.to_h.stringify_keys
-
-        return args unless container_klass.respond_to?(:contract)
-
-        restrict_to_optional_or_keys_from_contract(args)
-      end
-
-      private
-
-      def attach_call(async_job_class)
-        # e.g. SomeInteractor::AsyncWithSuffix.call(foo: 'bar')
-        async_job_class.send(:define_singleton_method, :call) do |context|
-          call!(context)
-        end
-      end
-
-      def attach_call!(async_job_class)
-        this = self
-
-        # e.g. SomeInteractor::AsyncWithSuffix.call!(foo: 'bar')
-        async_job_class.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 restrict_to_optional_or_keys_from_contract(args)
-        keys = container_klass
-               .contract
-               .expectations
-               .instance_eval { @terms }
-               .schema
-               .key_map
-               .to_dot_notation
-               .map(&:to_s)
-
-        optional = Array(container_klass.optional_attrs).map(&:to_s)
-        keys += optional
-
-        args.slice(*keys)
-      end
+    def async_job_klass
+      AsyncJobKlass.new(container_klass:, klass_suffix:).async_job_klass
     end
   end
 end

data/lib/interactify/jobable.rb

@@ -1,4 +1,6 @@
-require 'interactify/job_maker'
+# frozen_string_literal: true
+
+require "interactify/job_maker"
 
 module Interactify
   module Jobable
@@ -18,7 +20,7 @@ module Interactify
 
         to_call = defined?(super_klass::Async) ? :interactor_job : :job_calling
 
-        klass.send(to_call, opts: opts, method_name: jobable_method_name)
+        klass.send(to_call, opts:, method_name: jobable_method_name)
         super(klass)
       end
     end
@@ -51,18 +53,18 @@ module Interactify
       # 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: '')
+      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_class)
+        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_class)
+        const_set("Async#{klass_suffix}", job_maker.async_job_klass)
       end
 
       # if this was defined in ExampleClass this creates the following class
@@ -80,10 +82,10 @@ module Interactify
       # # 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: '')
+      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_class)
+        const_set("Job#{klass_suffix}", job_maker.job_klass)
       end
     end
   end

data/lib/interactify/mismatching_promise_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "interactify/contract_failure"
+
+module Interactify
+  class MismatchingPromiseError < ContractFailure
+    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

data/lib/interactify/organizer_call_monkey_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Interactify
   module OrganizerCallMonkeyPatch
     extend ActiveSupport::Concern
@@ -30,8 +32,11 @@ module Interactify
     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.instance_variable_set(
+          :@_interactor_called_by_non_bang_method,
+          @_interactor_called_by_non_bang_method
+        )
 
         instance.tap(&:run!)
       end