interactor_support 1.0.1

data/lib/interactor_support/concerns/transformable.rb

@@ -0,0 +1,65 @@
+module InteractorSupport
+  module Concerns
+    module Transformable
+      extend ActiveSupport::Concern
+      include InteractorSupport::Core
+
+      included do
+        class << self
+          # context_variable first_post: Post.first
+          # context_variable user: -> { User.find(user_id) }
+          # context_variable items: Item.all
+          # context_variable numbers: [1, 2, 3]
+          def context_variable(key_values)
+            before do
+              key_values.each do |key, value|
+                context[key] = if value.is_a?(Proc)
+                  context.instance_exec(&value)
+                else
+                  value
+                end
+              end
+            end
+          end
+
+          # transform :email, :name, with: [:downcase, :strip]
+          # transform :url, with: :downcase
+          # transform :items, with: :compact
+          # transform :items, with: ->(value) { value.compact }
+          # transform :email, :url, with: ->(value) { value.downcase.strip }
+          # transform :items, with: :compact
+          def transform(*keys, with: [])
+            before do
+              if keys.empty?
+                raise ArgumentError, 'transform action requires at least one key.'
+              end
+
+              keys.each do |key|
+                if with.is_a?(Proc)
+                  begin
+                    context[key] = context.instance_exec(&with)
+                  rescue => e
+                    context.fail!(errors: ["#{key} failed to transform: #{e.message}"])
+                  end
+                elsif with.is_a?(Array)
+                  context.fail!(errors: ["#{key} does not respond to all transforms"]) unless with.all? do |t|
+                    t.is_a?(Symbol) && context[key].respond_to?(t)
+                  end
+                  context[key] = with.inject(context[key]) do |value, method|
+                    value.send(method)
+                  end
+                elsif with.is_a?(Symbol) && context[key].respond_to?(with)
+                  context[key] = context[key].send(with)
+                elsif with.is_a?(Symbol)
+                  context.fail!(errors: ["#{key} does not respond to #{with}"])
+                else
+                  raise ArgumentError, 'transform requires `with` to be a symbol or array of symbols.'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interactor_support/concerns/updatable.rb

@@ -0,0 +1,57 @@
+module InteractorSupport
+  module Concerns
+    module Updatable
+      extend ActiveSupport::Concern
+      include InteractorSupport::Core
+
+      included do
+        class << self
+          def update(model, attributes: {}, context_key: nil)
+            context_key ||= model
+
+            before do
+              record = context[model]
+              context.fail!(errors: ["#{model} not found"]) unless record
+
+              update_data =
+                case attributes
+                when Hash
+                  attributes.each_with_object({}) do |(key, value), result|
+                    case value
+                    when Hash
+                      parent = context[key]
+                      context.fail!(errors: ["#{key} not found"]) unless parent
+                      result.merge!(value.transform_values { |v| parent[v] })
+                    when Array
+                      parent = context[key]
+                      context.fail!(errors: ["#{key} not found"]) unless parent
+                      result.merge!(value.index_with { |v| parent[v] })
+                    when Proc
+                      begin
+                        result[key] = context.instance_exec(&value)
+                      rescue StandardError => e
+                        context.fail!(errors: [e.message])
+                      end
+                    else
+                      result[key] = context.send(value)
+                    end
+                  end
+                when Symbol
+                  data = context[attributes]
+                  context.fail!(errors: ["#{attributes} not found"]) unless data
+                  data
+                else
+                  raise ArgumentError, "Invalid attributes: #{attributes}"
+                end
+
+              record.update!(update_data)
+
+              # Assign the updated record to context
+              context[context_key] = record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interactor_support/configuration.rb

@@ -0,0 +1,18 @@
+module InteractorSupport
+  class Configuration
+    attr_accessor :request_object_behavior, :request_object_key_type
+
+    def initialize
+      # Default configuration values.
+      # :returns_context - request objects return a context object.
+      # :returns_self - request objects return self.
+      @request_object_behavior = :returns_context
+
+      # Default configuration values, only applies when request_object_behavior is :returns_context.
+      # :string - request object keys are strings.
+      # :symbol - request object keys are symbols.
+      # :struct - request object keys are struct objects.
+      @request_object_key_type = :symbol
+    end
+  end
+end

data/lib/interactor_support/core.rb

@@ -0,0 +1,10 @@
+module InteractorSupport
+  module Core
+    class << self
+      def included(base)
+        # Only include Interactor if it isn’t already present.
+        base.include(Interactor) unless base.included_modules.include?(Interactor)
+      end
+    end
+  end
+end

data/lib/interactor_support/request_object.rb

@@ -0,0 +1,86 @@
+# app/concerns/interactor_support/request_object.rb
+module InteractorSupport
+  module RequestObject
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Validations::Callbacks
+
+      def initialize(attributes = {})
+        super(attributes)
+        raise ActiveModel::ValidationError, self unless valid?
+      end
+
+      def to_context
+        key_type = InteractorSupport.configuration.request_object_key_type
+        attrs = attributes.each_with_object({}) do |(name, value), hash|
+          name = key_type == :string ? name.to_s : name.to_sym
+          hash[name] = if value.respond_to?(:to_context)
+            value.to_context
+          elsif value.is_a?(Array) && value.first.respond_to?(:to_context)
+            value.map(&:to_context)
+          else
+            value
+          end
+        end
+        return Struct.new(*attrs.keys).new(*attrs.values) if key_type == :struct
+
+        attrs
+      end
+
+      class << self
+        def new(*args, **kwargs)
+          return super(*args, **kwargs) if InteractorSupport.configuration.request_object_behavior == :returns_self
+
+          super(*args, **kwargs).to_context
+        end
+
+        # Accepts one or more attribute names along with options.
+        #
+        # Options:
+        #   - type: a class to cast the value (often another RequestObject)
+        #   - array: when true, expects an array; each element is cast.
+        #   - default: default value for the attribute.
+        #   - transform: a symbol or an array of symbols that will be applied (if the value responds to them).
+        def attribute(*names, type: nil, array: false, default: nil, transform: nil)
+          names.each do |name|
+            transform_options[name.to_sym] = transform if transform.present?
+            super(name, default: default)
+            original_writer = instance_method("#{name}=")
+            define_method("#{name}=") do |value|
+              # Apply transforms immediately if provided.
+              if transform
+                Array(transform).each do |method|
+                  if value.respond_to?(method)
+                    value = value.send(method)
+                  elsif respond_to?(method)
+                    value = send(method, value)
+                  else
+                    raise ArgumentError, "transform method #{method} not found"
+                  end
+                end
+              end
+              # Type: only wrap if not already an instance.
+              if type
+                value = if array
+                  Array(value).map { |v| v.is_a?(type) ? v : type.new(v) }
+                else
+                  value.is_a?(type) ? value : type.new(value)
+                end
+              end
+              original_writer.bind(self).call(value)
+            end
+          end
+        end
+
+        private
+
+        def transform_options
+          @_transform_options ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/interactor_support/rubocop/cop/base_interactor_cop.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    class BaseInteractorCop < RuboCop::Cop::Base
+      def on_class(node)
+        check_interactor_usage(node)
+      end
+
+      def on_module(node)
+        check_interactor_usage(node)
+      end
+
+      private
+
+      def extract_included_modules(node)
+        node.each_descendant(:send)
+          .select { |send_node| send_node.method?(:include) }
+          .map { |send_node| [send_node, send_node.first_argument&.const_name] }
+          .reject { |_, name| name.nil? }
+      end
+
+      def extract_used_methods(node)
+        node.each_descendant(:send).map(&:method_name)
+      end
+
+      def known_module_methods
+        {
+          'InteractorSupport::Concerns::Findable' => [:find_by, :find_where],
+          'InteractorSupport::Concerns::Skippable' => [:skip],
+          'InteractorSupport::Concerns::Transactionable' => [:transaction],
+          'InteractorSupport::Concerns::Transformable' => [:context_variable, :transform],
+          'InteractorSupport::Concerns::Updatable' => [:update],
+          'InteractorSupport::Validations' => validations_methods,
+        }
+      end
+
+      def module_for_method_name(method_name)
+        known_module_methods.each do |mod, methods|
+          return mod if methods.include?(method_name)
+        end
+        nil
+      end
+
+      def validations_methods
+        [
+          :required,
+          :optional,
+          :context_accessor,
+          :validates_after,
+          :validates_before,
+          :after_validation,
+          :before_validation,
+          :validates_acceptance_of,
+          :validates_numericality_of,
+          :validates_presence_of,
+          :validates_length_of,
+          :validates_size_of,
+          :validates_comparison_of,
+          :validates_confirmation_of,
+          :validates_absence_of,
+          :validates_exclusion_of,
+          :validates_format_of,
+          :validates_inclusion_of,
+          :human_attribute_name,
+          :lookup_ancestors,
+          :i18n_scope,
+          :descendants,
+          :reset_callbacks,
+          :define_callbacks,
+          :set_callback,
+          :normalize_callback_params,
+          :get_callbacks,
+          :set_callbacks,
+          :skip_callback,
+          :define_model_callbacks,
+          :model_name,
+          :clear_validators!,
+          :validators_on,
+          :attribute_method?,
+          :validates,
+          :validates!,
+          :validates_each,
+          :validates_with,
+          :validate,
+          :validators,
+          :yaml_tag,
+        ]
+      end
+    end
+  end
+end

data/lib/interactor_support/rubocop/cop/require_required_for_interactor_support.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class RequireRequiredForInteractorSupport < Cop
+      MSG = 'Classes including `InteractorSupport` or `InteractorSupport::Validations` must invoke `required`.'
+
+      def_node_matcher :calls_required?, <<~PATTERN
+        (send nil? :required ...)
+      PATTERN
+
+      def includes_support?(node)
+        node.to_s =~ /InteractorSupport/ && (
+          node.to_s =~ /\(const nil :InteractorSupport\) :Validations\)/ ||
+          (node.to_s =~ /\(const nil :InteractorSupport\)/ && node.to_s !~ /:RequestObject/)
+        )
+      end
+
+      def on_class(node)
+        return unless includes_support?(node)
+
+        required_called = calls_required?(node.body) || node.body&.children&.any? do |child|
+          calls_required?(child)
+        end
+        add_offense(node, message: MSG) unless required_called
+      end
+    end
+  end
+end

data/lib/interactor_support/rubocop/cop/unused_included_modules.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative 'base_interactor_cop'
+
+module RuboCop
+  module Cop
+    class UnusedIncludedModules < BaseInteractorCop
+      MSG_SINGLE = 'Module `%<module>s` is included but its methods are not used in this class.'
+      MSG_GROUP = 'Use `%<correct_modules>s` instead.'
+
+      GROUP_MODULES = {
+        'InteractorSupport' => [
+          'InteractorSupport::Concerns::Findable',
+          'InteractorSupport::Concerns::Skippable',
+          'InteractorSupport::Concerns::Transactionable',
+          'InteractorSupport::Concerns::Transformable',
+          'InteractorSupport::Concerns::Updatable',
+          'InteractorSupport::Validations',
+        ],
+        'InteractorSupport::Actions' => [
+          'InteractorSupport::Concerns::Skippable',
+          'InteractorSupport::Concerns::Transactionable',
+          'InteractorSupport::Concerns::Updatable',
+          'InteractorSupport::Concerns::Findable',
+          'InteractorSupport::Concerns::Transformable',
+        ],
+      }.freeze
+
+      private
+
+      def check_interactor_usage(node)
+        included_modules = extract_included_modules(node)
+        used_methods = extract_used_methods(node)
+
+        included_modules.each do |include_node, mod|
+          next unless mod.start_with?('InteractorSupport')
+          next if mod == 'InteractorSupport::RequestObject'
+
+          expanded_modules = GROUP_MODULES.fetch(mod, [mod])
+          unused_modules = expanded_modules.reject do |m|
+            known_module_methods[m]&.any? { |meth| used_methods.include?(meth) }
+          end
+
+          next if unused_modules.empty?
+
+          missing_modules = []
+          used_methods.each do |method_name|
+            missing_module = module_for_method_name(method_name)
+            next if missing_module.nil? || included_modules.any? { |_, mod| mod == missing_module }
+
+            missing_modules << missing_module unless missing_modules.include?(missing_module)
+          end
+
+          modules = missing_modules.map { |missing_module| "include #{missing_module}" }
+          message = if unused_modules.size == 1
+            format(MSG_SINGLE, module: unused_modules.first)
+          else
+            format(MSG_GROUP, correct_modules: modules.join(', '))
+          end
+
+          add_offense(include_node, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/interactor_support/rubocop/cop/used_unincluded_modules.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative 'base_interactor_cop'
+
+module RuboCop
+  module Cop
+    class UsedUnincludedModules < BaseInteractorCop
+      MSG_MISSING_INTERACTOR = '`include Interactor` is required when including `%<module>s`.'
+      MSG_MISSING_MODULE = 'Method `%<method>s` is used but `%<module>s` is not included.'
+
+      private
+
+      def check_interactor_usage(node)
+        included_modules = extract_included_modules(node)
+        used_methods = extract_used_methods_with_nodes(node)
+
+        interactor_included = included_modules.any? { |_, mod| mod == 'Interactor' }
+
+        included_modules.each do |include_node, mod|
+          if mod.start_with?('InteractorSupport') && !interactor_included
+            add_offense(include_node, message: format(MSG_MISSING_INTERACTOR, module: mod))
+          end
+        end
+
+        return unless interactor_included
+
+        used_methods.each do |method_name, method_node|
+          missing_module = module_for_method_name(method_name)
+          next if missing_module.nil? || included_modules.any? { |_, mod| mod == missing_module }
+
+          # Register offense on the exact method call
+          add_offense(
+            method_node,
+message: format(MSG_MISSING_MODULE, method: method_name, module: missing_module),
+severity: :info,
+          )
+        end
+      end
+
+      def extract_used_methods_with_nodes(node)
+        node.each_descendant(:send).map { |send_node| [send_node.method_name, send_node] }
+      end
+    end
+  end
+end

data/lib/interactor_support/rubocop.rb

@@ -0,0 +1,2 @@
+require_relative 'rubocop/cop/require_required_for_interactor_support'
+require_relative 'rubocop/cop/unused_included_modules'

data/lib/interactor_support/validations.rb

@@ -0,0 +1,116 @@
+require 'active_model'
+
+module InteractorSupport
+  module Validations
+    extend ActiveSupport::Concern
+    include InteractorSupport::Core
+
+    included do
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+    end
+
+    class_methods do
+      def required(*keys)
+        apply_validations(keys, required: true)
+      end
+
+      def optional(*keys)
+        apply_validations(keys, required: false)
+      end
+
+      def validates_after(*keys, **validations)
+        after do
+          keys.each do |key|
+            apply_custom_validations(key, validations)
+          end
+        end
+      end
+
+      def validates_before(*keys, **validations)
+        before do
+          if validations[:persisted]
+            context.fail!(errors: ['persisted validation is only available for after validations'])
+          end
+
+          keys.each do |key|
+            apply_custom_validations(key, validations)
+          end
+        end
+      end
+
+      private
+
+      def apply_validations(keys, required:)
+        keys.each do |key|
+          if key.is_a?(Hash)
+            key.each do |attribute, validation_options|
+              attr_accessor(attribute)
+
+              define_context_methods(attribute)
+              if required
+                validates(attribute, validation_options)
+              else
+                validates(attribute, validation_options.merge(allow_nil: true))
+              end
+            end
+          else
+            attr_accessor(key)
+
+            define_context_methods(key)
+            validates(key, presence: true) if required
+          end
+        end
+        # Ensure validations run before execution
+        before do
+          context.fail!(errors: errors.full_messages) unless valid?
+        end
+      end
+
+      def define_context_methods(key)
+        define_method(key) { context[key] }
+        define_method("#{key}=") { |value| context[key] = value }
+      end
+    end
+
+    def apply_custom_validations(key, validations)
+      validation_for_presence(key) if validations[:presence]
+      validation_for_inclusion(key, validations[:inclusion]) if validations[:inclusion]
+      validation_for_persistence(key) if validations[:persisted]
+      validation_for_type(key, validations[:type]) if validations[:type]
+    end
+
+    def validation_for_type(key, type)
+      context.fail!(errors: ["#{key} was not of type #{type}"]) unless context[key].is_a?(type)
+    end
+
+    def validation_for_inclusion(key, inclusion)
+      unless inclusion.is_a?(Hash) && inclusion[:in].is_a?(Enumerable)
+        raise ArgumentError, 'inclusion validation requires an :in key with an array or range'
+      end
+
+      context.fail!(errors: ["#{key} was not in the specified inclusion"]) unless inclusion[:in].include?(context[key])
+    rescue ArgumentError => e
+      context.fail!(errors: [e.message])
+    end
+
+    def validation_for_presence(key)
+      context.fail!(errors: ["#{key} does not exist"]) unless context[key].present?
+    end
+
+    def validation_for_persistence(key)
+      validation_for_presence(key)
+      unless context[key].is_a?(ApplicationRecord)
+        context.fail!(
+          errors: [
+            "#{key} is not an ApplicationRecord, which is required for persisted validation",
+          ],
+        )
+      end
+
+      context.fail!(
+        errors: ["#{key} was not persisted"] + context[key].errors.full_messages,
+      ) unless context[key].persisted?
+    end
+  end
+end

data/lib/interactor_support/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module InteractorSupport
+  VERSION = '1.0.1'
+end

data/lib/interactor_support.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'interactor'
+require 'logger'
+require 'active_support/concern'
+require_relative 'interactor_support/core'
+require_relative 'interactor_support/version'
+require_relative 'interactor_support/actions'
+require_relative 'interactor_support/validations'
+require_relative 'interactor_support/request_object'
+require_relative 'interactor_support/configuration'
+
+Dir[File.join(__dir__, 'interactor_support/concerns/*.rb')].sort.each { |file| require file }
+
+module InteractorSupport
+  extend ActiveSupport::Concern
+
+  class << self
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  included do
+    include InteractorSupport::Actions
+    include InteractorSupport::Validations
+  end
+end

data/sig/interactor_support.rbs

@@ -0,0 +1,4 @@
+module InteractorSupport
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end