interactify 0.1.0.pre.alpha.1 → 0.3.0.pre.alpha.1

data/lib/interactify/interactor_wiring/callable_representation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "interactify/interactor_wiring/error_context"
+
+module Interactify
+  class InteractorWiring
+    class CallableRepresentation
+      attr_reader :filename, :klass, :wiring
+
+      delegate :interactor_lookup, to: :wiring
+
+      def initialize(filename:, klass:, wiring:)
+        @filename = filename
+        @klass = klass
+        @wiring = wiring
+      end
+
+      def validate_callable(error_context: ErrorContext.new)
+        if organizer?
+          assign_previously_defined(error_context:)
+          validate_children(error_context:)
+        end
+
+        validate_self(error_context:)
+      end
+
+      def expected_keys
+        klass.respond_to?(:expected_keys) ? Array(klass.expected_keys) : []
+      end
+
+      def promised_keys
+        klass.respond_to?(:promised_keys) ? Array(klass.promised_keys) : []
+      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) && klass.organized.any?
+      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|
+          interactor_as_callable = interactor_lookup[interactor]
+          next if interactor_as_callable.nil?
+
+          error_context = interactor_as_callable.validate_callable(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
+    end
+  end
+end

data/lib/interactify/interactor_wiring/constants.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Interactify
+  class InteractorWiring
+    class Constants
+      attr_reader :root, :organizer_files, :interactor_files
+
+      def initialize(root:, organizer_files:, interactor_files:)
+        @root = root.is_a?(Pathname) ? root : Pathname.new(root)
+        @organizer_files = organizer_files
+        @interactor_files = interactor_files
+      end
+
+      def organizers
+        @organizers ||= organizer_files.flat_map do |f|
+          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 interactor_lookup
+        @interactor_lookup ||= (interactors + organizers).index_by(&:klass)
+      end
+
+      private
+
+      def callables_in_file(filename)
+        @callables_in_file ||= {}
+
+        @callables_in_file[filename] ||= _callables_in_file(filename)
+      end
+
+      def _callables_in_file(filename)
+        constant = constant_for(filename)
+        return if constant == Interactify
+
+        internal_klasses = internal_constants_for(constant)
+
+        ([constant] + internal_klasses).map do |k|
+          new_callable(filename, k, self)
+        end
+      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
+          begin
+            "#{constant.name}::#{symbol}".constantize
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def interactor_klass?(object)
+        return unless object.is_a?(Class) && object.ancestors.include?(Interactor)
+        return if object.is_a?(Sidekiq::Job)
+
+        true
+      end
+
+      def new_callable(filename, klass, wiring)
+        CallableRepresentation.new(filename:, klass:, wiring:)
+      end
+
+      def constant_for(filename)
+        require filename
+
+        underscored_klass_name = underscored_klass_name(filename)
+        underscored_klass_name = trim_rails_design_pattern_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
+
+        Object.const_get(klass_name)
+      end
+
+      # Example:
+      # trim_rails_folder("app/interactors/namespace/sub_namespace/class_name.rb")
+      # => "namespace/sub_namespace/class_name.rb"
+      def trim_rails_design_pattern_folder(filename)
+        rails_folders.each do |folder|
+          regexable_folder = Regexp.quote("#{folder}/")
+          regex = /^#{regexable_folder}/
+
+          return filename.gsub(regex, "") if filename.match?(regex)
+        end
+
+        filename
+      end
+
+      def rails_folders = Dir.glob(root / "*").map { Pathname.new _1 }.select(&:directory?).map { |f| File.basename(f) }
+
+      # 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']
+      def underscored_klass_name(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']
+                .join("/")             # 'namespace/sub_namespace/class_name.rb'
+                .gsub(/\.rb\z/, "")     # 'namespace/sub_namespace/class_name'
+      end
+    end
+  end
+end

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