activeinteractor 0.1.7 → 1.0.0.beta.1

data/lib/active_interactor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_model'
+require 'active_support/dependencies/autoload'
 
 require 'active_interactor/version'
 
@@ -23,46 +23,28 @@ require 'active_interactor/version'
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
-#
-# @author Aaron Allen <hello@aaronmallen.me>
-# @since 0.0.1
-# @version 0.2
 module ActiveInteractor
   extend ActiveSupport::Autoload
 
   autoload :Base
-  autoload :Configuration
   autoload :Context
-  autoload :Interactor
   autoload :Organizer
 
   eager_autoload do
     autoload :Error
   end
 
-  class << self
-    # The ActiveInteractor configuration
-    # @return [ActiveInteractor::Configuration] the configuration instance
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Configures the ActiveInteractor gem
-    #
-    # @example Configure ActiveInteractor
-    #  ActiveInteractor.configure do |config|
-    #    config.logger = Rails.logger
-    #  end
-    #
-    # @yield [ActiveInteractor#configuration]
-    def configure
-      yield(configuration)
-    end
+  # The ActiveInteractor logger object
+  # @return [Logger] an instance of Logger
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
 
-    # The ActiveInteractor logger object
-    # @return [Logger] the configured logger instance
-    def logger
-      configuration.logger
-    end
+  # Set the ActiveInteractor logger object
+  # @example
+  #   ActiveInteractor.logger = ::Rails.logger
+  # @return [Logger] an instance of Logger
+  def self.logger=(logger)
+    @logger = logger
   end
 end

data/lib/active_interactor/base.rb

@@ -1,19 +1,29 @@
 # frozen_string_literal: true
 
+require 'active_interactor/interactor'
+
 module ActiveInteractor
-  # The Base Interactor class inherited by all interactors
-  #
+  # The base interactor class. All interactors should inherit from
+  #  {Base}.
   # @author Aaron Allen <hello@aaronmallen.me>
   # @since 0.0.1
-  # @version 0.1
+  # @example a basic interactor
+  #  class MyInteractor < ActiveInteractor::Base
+  #    def perform
+  #      context.called = true
+  #    end
+  #  end
+  #
+  #  MyInteractor.perform
+  #  #=> <MyInteractor::Context called=true>
   class Base
     include Interactor
 
-    # A new instance of {Base}
-    # @param context [Hash, nil] the properties of the context
-    # @return [ActiveInteractor::Base] a new instance of {Base}
-    def initialize(context = {})
-      @context = self.class.context_class.new(self, context)
+    # Duplicates an instance of {Base}
+    # @since 1.0.0-alpha.1
+    # @return [Base] a new instance of {Base}
+    def dup
+      self.class.new(context.dup)
     end
   end
 end

data/lib/active_interactor/context.rb

@@ -1,190 +1,13 @@
 # frozen_string_literal: true
 
-require 'ostruct'
-
-Dir[File.expand_path('context/*.rb', __dir__)].each { |file| require file }
-
 module ActiveInteractor
-  # ActiveInteractor::Context module
-  #
+  # ActiveInteractor::Context classes
   # @author Aaron Allen <hello@aaronmallen.me>
   # @since 0.0.1
-  # @version 0.1
   module Context
-    # The base context class inherited by all {Interactor::Context} classes
-    #
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 0.0.1
-    # @version 0.2
-    class Base < OpenStruct
-      include ActiveModel::Validations
-      include Attributes
-
-      # A new instance of {Base}
-      # @param interactor [ActiveInteractor::Base] an interactor instance
-      # @param attributes [Hash, nil] the attributes of the context
-      # @return [ActiveInteractor::Context::Base] a new instance of {Base}
-      def initialize(interactor, attributes = {})
-        copy_flags!(attributes)
-        @interactor = interactor
-        super(attributes)
-      end
-
-      # Track that an Interactor has been called. The {#called!} method
-      #  is used by the interactor being invoked with this context. After an
-      #  interactor is successfully called, the interactor instance is tracked in
-      #  the context for the purpose of potential future rollback
-      #
-      # @return [Array<ActiveInteractor::Base>] all called interactors
-      def called!
-        _called << interactor
-      end
-
-      # Fail the context instance. Failing a context raises an error
-      #  that may be rescued by the calling interactor. The context is also flagged
-      #  as having failed
-      #
-      # @example Fail an interactor context
-      #  interactor = MyInteractor.new(name: 'Aaron')
-      #  #=> <#MyInteractor name='Aaron'>
-      #
-      #  interactor.context.fail!
-      #  #=> ActiveInteractor::Error::ContextFailure: <#MyInteractor::Context name='Aaron'>
-      #
-      # @param errors [ActiveModel::Errors, Hash] errors to add to the context on failure
-      # @see https://api.rubyonrails.org/classes/ActiveModel/Errors.html ActiveModel::Errors
-      # @raise [Error::ContextFailure]
-      def fail!(errors = {})
-        merge_errors(errors)
-        mark_failed!
-        raise_context_failure!
-      end
-
-      # Whether the context instance has failed. By default, a new
-      # context is successful and only changes when explicitly failed
-      #
-      # @note The {#failure?} method is the inverse of the {#success?} method
-      #
-      # @example Check if a context has failed
-      #  context = MyInteractor::Context.new
-      #  #=> <#MyInteractor::Context>
-      #
-      #  context.failure?
-      #  false
-      #
-      #  context.fail!
-      #  #=> ActiveInteractor::Error::ContextFailure: <#MyInteractor::Context>
-      #
-      #  context.failure?
-      #  #=> true
-      #
-      # @return [Boolean] `false` by default or `true` if failed
-      def failure?
-        @_failed || false
-      end
-      alias fail? failure?
-
-      # Attempt to call the interactor for missing validation callback methods
-      # @raise [NameError] if the method is not a validation callback or method
-      #  does not exist on the interactor instance
-      def method_missing(name, *args, &block)
-        interactor.send(name, *args, &block) if validation_callback?(name)
-        super
-      end
-
-      # Attempt to call the interactor for missing validation callback methods
-      # @return [Boolean] `true` if method is a validation callback and exists
-      #  on the interactor instance
-      def respond_to_missing?(name, include_private)
-        return false unless validation_callback?(name)
-
-        interactor.respond_to?(name, include_private)
-      end
-
-      # Roll back an interactor context. Any interactors to which this
-      # context has been passed and which have been successfully called are asked
-      # to roll themselves back by invoking their
-      # {ActiveInteractor::Interactor#rollback #rollback} instance methods.
-      #
-      # @example Rollback an interactor's context
-      #  context = MyInteractor.perform(name: 'Aaron')
-      #  #=> <#MyInteractor::Context name='Aaron'>
-      #
-      #  context.rollback!
-      #  #=> true
-      #
-      #  context
-      #  #=> <#MyInteractor::Context name='Aaron'>
-      #
-      # @return [Boolean] `true` if rolled back successfully or `false` if already
-      #  rolled back
-      def rollback!
-        return false if @_rolled_back
-
-        rollback_called
-        mark_rolledback!
-      end
-
-      # Whether the context instance is successful. By default, a new
-      # context is successful and only changes when explicitly failed
-      #
-      # @note the {#success?} method is the inverse of the {#failure?} method
-      #
-      # @example Check if a context has failed
-      #  context = MyInteractor::Context.new
-      #  #=> <#MyInteractor::Context>
-      #
-      #  context.success?
-      #  true
-      #
-      #  context.fail!
-      #  #=> ActiveInteractor::Error::ContextFailure: <#MyInteractor::Context>
-      #
-      #  context.success?
-      #  #=> false
-      #
-      # @return [Boolean] `true` by default or `false` if failed
-      def success?
-        !failure?
-      end
-      alias successful? success?
-
-      private
-
-      attr_reader :interactor
-
-      def copy_flags!(context)
-        @_called = context.send(:_called) if context.respond_to?(:_called, true)
-        @_failed = context.failure? if context.respond_to?(:failure?)
-      end
-
-      def _called
-        @_called ||= []
-      end
-
-      def mark_failed!
-        @_failed = true
-      end
-
-      def mark_rolledback!
-        @_rolled_back = true
-      end
-
-      def merge_errors(errors)
-        self.errors.merge!(errors) unless errors.empty?
-      end
-
-      def raise_context_failure!
-        raise Error::ContextFailure, self
-      end
-
-      def rollback_called
-        _called.reverse_each(&:execute_rollback)
-      end
+    extend ActiveSupport::Autoload
 
-      def validation_callback?(method_name)
-        _validate_callbacks.map(&:filter).include?(method_name)
-      end
-    end
+    autoload :Base
+    autoload :Loader
   end
 end

data/lib/active_interactor/context/attributes.rb

@@ -1,190 +1,78 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/class/attribute'
-
 module ActiveInteractor
   module Context
-    # Provides Context Attribute methods to included classes
-    #
+    # Context attribute methods included by all {Context::Base}
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 0.1.4
-    # @version 0.1
     module Attributes
-      extend ActiveSupport::Concern
-
-      included do
-        extend ClassMethods
-        class_attribute :__default_attributes, instance_writer: false, default: []
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
       end
 
+      # Context attribute class methods extended by all {Context::Base}
       module ClassMethods
-        # Attributes defined on the context class
-        #
+        # Set or get attributes defined on the context class
+        # @example Set attributes on a context class
+        #   class MyInteractor::Context < ActiveInteractor::Context::Base
+        #     attributes :first_name, :last_name
+        #   end
         # @example Get attributes defined on a context class
         #  MyInteractor::Context.attributes
         #  #=> [:first_name, :last_name]
-        #
-        # @return [Array<Symbol>] the defined attributes
-        def attributes
-          __default_attributes
-            .concat(_validate_callbacks.map(&:filter).map(&:attributes).flatten)
-            .flatten
-            .uniq
-        end
-
-        # Set attributes on a context class
-        #
-        # @param attributes [Array<Symbol, String>] the attributes of the context
-        #
-        # @example Define attributes on a context class
-        #  MyInteractor::Context.attributes = :first_name, :last_name
-        #  #=> [:first_name, :last_name]
-        #
         # @return [Array<Symbol>] the defined attributes
-        def attributes=(*attributes)
-          self.__default_attributes = self.attributes.concat(attributes.flatten.map(&:to_sym)).uniq
-        end
-
-        # Attribute aliases defined on the context class
-        #
-        # @example Get attribute aliases defined on a context class
-        #  MyInteractor::Context.attribute_aliases
-        #  #=> { last_name: [:sir_name] }
-        #
-        # @return [Hash{Symbol => Array<Symbol>}]
-        def attribute_aliases
-          @attribute_aliases ||= {}
-        end
+        def attributes(*attributes)
+          return __attributes if attributes.empty?
 
-        # Set attribute aliases on the context class
-        #
-        # @param aliases [Hash{Symbol => Symbol, Array<Symbol>}] the attribute aliases of
-        #  the context
-        #
-        # @return [Hash{Symbol => Array<Symbol>}]
-        def alias_attributes(aliases = {})
-          map_attribute_aliases(aliases)
-          attribute_aliases
+          @__attributes = __attributes.concat(attributes).compact.uniq.sort
         end
 
         private
 
-        def map_attribute_aliases(aliases)
-          aliases.each_key do |attribute|
-            key = attribute.to_sym
-            attribute_aliases[key] ||= []
-            attribute_aliases[key].concat(Array.wrap(aliases[attribute]).map(&:to_sym))
-          end
+        def __attributes
+          @__attributes ||= []
         end
       end
 
-      def initialize(attributes = {})
-        super(map_attributes(attributes))
+      # @api private
+      # @param context [Hash|Context::Base] attributes to assign to the context
+      # @return [Context::Base] a new instance of {Context::Base}
+      def initialize(context = {})
+        copy_flags!(context)
+        super
       end
 
       # Attributes defined on the instance
-      #
       # @example Get attributes defined on an instance
-      #  MyInteractor::Context.attributes = :first_name, :last_name
-      #  #=> [:first_name, :last_name]
-      #
-      #  context = MyInteractor::Context.new(first_name: 'Aaron', last_name: 'Allen')
-      #  #=> <#MyInteractor::Context first_name='Aaron', last_name='Allen'>
-      #
-      #  context.attributes
-      #  #=> { first_name: 'Aaron', last_name: 'Allen' }
-      #
-      # @example Get attributes defined on an instance with unknown attribute
-      #  MyInteractor::Context.attributes = :first_name, :last_name
-      #  #=> [:first_name, :last_name]
-      #
-      #  context = MyInteractor::Context.new(first_name: 'Aaron', last_name: 'Allen', unknown: 'unknown')
-      #  #=> <#MyInteractor::Context first_name='Aaron', last_name='Allen', unknown='unknown'>
+      #   class MyInteractor::Context < ActiveInteractor::Context::Base
+      #     attributes :first_name, :last_name
+      #   end
       #
-      #  context.attributes
-      #  #=> { first_name: 'Aaron', last_name: 'Allen' }
+      #   class MyInteractor < ActiveInteractor::Base
+      #     def perform; end
+      #   end
       #
-      #  context.unknown
-      #  #=> 'unknown'
+      #   result = MyInteractor.perform(first_name: 'Aaron', last_name: 'Allen', occupation: 'Software Nerd')
+      #   #=> <#MyInteractor::Context first_name='Aaron' last_name='Allen' occupation='Software Nerd'>
       #
-      # @return [Hash{Symbol => *}] the defined attributes and values
+      #   result.attributes
+      #   #=> { first_name: 'Aaron', last_name: 'Allen' }
+      # @return [Hash{Symbol=>*}] the defined attributes and values
       def attributes
         self.class.attributes.each_with_object({}) do |attribute, hash|
           hash[attribute] = self[attribute] if self[attribute]
         end
       end
 
-      # Removes properties from the instance that are not
-      # explicitly defined in the context instance {#attributes}
-      #
-      # @example Clean an instance of Context with unknown attribute
-      #  MyInteractor::Context.attributes = :first_name, :last_name
-      #  #=> [:first_name, :last_name]
-      #
-      #  context = MyInteractor::Context.new(first_name: 'Aaron', last_name: 'Allen', unknown: 'unknown')
-      #  #=> <#MyInteractor::Context first_name='Aaron', last_name='Allen', unknown='unknown'>
-      #
-      #  context.unknown
-      #  #=> 'unknown'
-      #
-      #  context.clean!
-      #  #=> { unknown: 'unknown' }
-      #
-      #  context.unknown
-      #  #=> nil
-      #
-      # @return [Hash{Symbol => *}] the deleted attributes
-      def clean!
-        return {} if keys.empty?
-
-        clean_keys!
-      end
-
-      # All keys of properties currently defined on the instance
-      #
-      # @example An instance of Context with unknown attribute
-      #  MyInteractor::Context.attributes = :first_name, :last_name
-      #  #=> [:first_name, :last_name]
-      #
-      #  context = MyInteractor::Context.new(first_name: 'Aaron', last_name: 'Allen', unknown: 'unknown')
-      #  #=> <#MyInteractor::Context first_name='Aaron', last_name='Allen', unknown='unknown'>
-      #
-      #  context.keys
-      #  #=> [:first_name, :last_name, :unknown]
-      #
-      # @return [Array<Symbol>] keys defined on the instance
-      def keys
-        each_pair.map { |pair| pair[0].to_sym }
-      end
-
       private
 
-      def aliased_key(key)
-        self.class.attribute_aliases.each_pair do |attribute, aliases|
-          key = aliases.any? { |aliased| aliased == key.to_sym } ? attribute : key.to_sym
+      def copy_flags!(context)
+        %w[_called _failed _rolled_back].each do |flag|
+          value = context.instance_variable_get("@#{flag}")
+          instance_variable_set("@#{flag}", value)
         end
-        key
-      end
-
-      def clean_keys!
-        keys.reject { |key| self.class.attributes.include?(key) }.each_with_object({}) do |attribute, deleted|
-          deleted[attribute] = self[attribute] if self[attribute]
-          delete_field(key.to_s)
-        end
-      end
-
-      def map_attributes(attributes)
-        return {} unless attributes
-
-        attributes.keys.each_with_object({}) do |attribute, hash|
-          key = aliased_key(attribute)
-          hash[key] = attributes[attribute]
-        end
-      end
-
-      def new_ostruct_member!(name)
-        super(aliased_key(name))
       end
     end
   end