activeinteractor 1.0.0 → 1.0.5

data/lib/active_interactor/context/loader.rb

@@ -22,7 +22,7 @@ module ActiveInteractor
       # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
       # @return [Const] a class that inherits from {Base}
       def self.create(context_class_name, interactor_class)
-        interactor_class.const_set(context_class_name.to_s.classify, Class.new(BASE_CONTEXT))
+        interactor_class.const_set(context_class_name.to_s.camelize, Class.new(BASE_CONTEXT))
       end
 
       # Find or create a {Base context} class for a given {ActiveInteractor::Base interactor}. If a class exists

data/lib/active_interactor/context/status.rb

@@ -37,8 +37,9 @@ module ActiveInteractor
       # @see https://api.rubyonrails.org/classes/ActiveModel/Errors.html ActiveModel::Errors
       # @raise [Error::ContextFailure]
       def fail!(errors = nil)
-        merge_errors!(errors) if errors
+        handle_errors(errors) if errors
         @_failed = true
+        resolve
         raise ActiveInteractor::Error::ContextFailure, self
       end
 
@@ -59,6 +60,16 @@ module ActiveInteractor
       end
       alias fail? failure?
 
+      # Resolve an instance of {Base context}.  Called when an interactor
+      #  is finished with it's context.
+      #
+      # @since 1.0.3
+      # @return [self] the instance of {Base context}
+      def resolve
+        resolve_errors
+        self
+      end
+
       # {#rollback! Rollback} an instance of {Base context}. Any {ActiveInteractor::Base interactors} the instance has
       # been passed via the {#called!} method are asked to roll themselves back by invoking their
       # {Interactor::Perform#rollback #rollback} methods. The instance is also flagged as rolled back.
@@ -90,24 +101,6 @@ module ActiveInteractor
         !failure?
       end
       alias successful? success?
-
-      private
-
-      def _called
-        @_called ||= []
-      end
-
-      def copy_called!(context)
-        value = context.instance_variable_get('@_called') || []
-        instance_variable_set('@_called', value)
-      end
-
-      def copy_flags!(context)
-        %w[_failed _rolled_back].each do |flag|
-          value = context.instance_variable_get("@#{flag}")
-          instance_variable_set("@#{flag}", value)
-        end
-      end
     end
   end
 end

data/lib/active_interactor/interactor/context.rb

@@ -27,7 +27,43 @@ module ActiveInteractor
         #
         #    MyInteractor.context_class.attributes
         #    #=> [:first_name, :last_name]
-        delegate :attributes, to: :context_class, prefix: :context
+        #
+        # @!method context_attribute_missing(match, *args, &block)
+        #  Call {ActiveInteractor::Context::Base.attribute_missing .attribute_missing} on the {Base interactor} class'
+        #  {#context_class context class}
+        #
+        #  @since 1.0.1
+        #
+        # @!method context_respond_to_without_attributes?(method, include_private_methods = false)
+        #  Call {ActiveInteractor::Context::Base.respond_to_without_attributes? .respond_to_without_attributes?} on the
+        #  {Base interactor} class' {#context_class context class}
+        #
+        #  @since 1.0.1
+        delegate :attributes, :attribute_missing, :respond_to_without_attributes?, to: :context_class, prefix: :context
+
+        # @!method context_attribute(name, type=Type::Value.new, **options)
+        #  Call {ActiveInteractor::Context::Base.attribute .attribute} on the {Base interactor} class'
+        #  {#context_class context class}
+        #
+        #  @since 1.0.1
+        #
+        # @example Setting default values on the {ActiveInteractor::Context::Base context} class
+        #    class MyInteractor < ActiveInteractor::Base
+        #      context_attribute :first_name, default: -> { 'Aaron' }
+        #    end
+        #
+        #    MyInteractor.perform
+        #    #=> <#MyInteractor::Context first_name='Aaron'>
+        #
+        #   MyInteractor.perform(first_name: 'Bob')
+        #   #=> <#MyInteractor::Context first_name='Bob'>
+        #
+        # @!method context_attribute_names
+        #  Call {ActiveInteractor::Context::Base.attribute_names .attribute_names} on the {Base interactor} class'
+        #  {#context_class context class}
+        #
+        #  @since 1.0.1
+        delegate(*ActiveModel::Attributes::ClassMethods.instance_methods, to: :context_class, prefix: :context)
 
         # @!method context_attribute_method?(attribute)
         #  Call {ActiveInteractor::Context::Base.attribute_method? .attribute_method?} on the {Base interactor} class'
@@ -175,7 +211,7 @@ module ActiveInteractor
         # @return [Const] the {Base interactor} class' {ActiveInteractor::Context::Base context} class
         def contextualize_with(klass)
           @context_class = begin
-            context_class = klass.to_s.classify.safe_constantize
+            context_class = klass.to_s.camelize.safe_constantize
             raise(ActiveInteractor::Error::InvalidContextClass, klass) unless context_class
 
             context_class
@@ -183,18 +219,37 @@ module ActiveInteractor
         end
       end
 
+      # @!method context_attribute_missing(match, *args, &block)
+      #  Call {ActiveInteractor::Context::Base#attribute_missing #attribute_missing} on the {Base interactor} instance's
+      #  {ActiveInteractor::Context::Base context} instance
+      #
+      #  @since 1.0.1
+      #
+      # @!method context_attribute_names
+      #  Call {ActiveInteractor::Context::Base#attribute_names #attribute_names} on the {Base interactor} instance's
+      #  {ActiveInteractor::Context::Base context} instance
+      #
+      #  @since 1.0.1
+      #
       # @!method context_fail!(errors = nil)
       #  Call {ActiveInteractor::Context::Status#fail! #fail!} on the {Base interactor} instance's
       #  {ActiveInteractor::Context::Base context} instance
       #
       #  @since 1.0.0
       #
+      # @!method context_respond_to_without_attributes?(method, include_private_methods = false)
+      #  Call {ActiveInteractor::Context::Base#respond_to_without_attributes? #respond_to_without_attributes?} on the
+      #  {Base interactor} instance's {ActiveInteractor::Context::Base context} instance
+      #
+      #  @since 1.0.1
+      #
       # @!method context_rollback!
       #  Call {ActiveInteractor::Context::Status#rollback! #rollback!} on the {Base interactor} instance's
       #  {ActiveInteractor::Context::Base context} instance
       #
       #  @since 1.0.0
-      delegate :fail!, :rollback!, to: :context, prefix: true
+      delegate :attribute_missing, :attribute_names, :fail!, :respond_to_without_attributes?, :rollback!,
+               to: :context, prefix: true
 
       # @!method context_errors
       #  Call {ActiveInteractor::Context::Base#errors #errors} on the {Base interactor} instance's
@@ -311,6 +366,7 @@ module ActiveInteractor
       # @return [Class] the {ActiveInteractor::Context::Base context} instance
       def finalize_context!
         context.called!(self)
+        context.resolve
         context
       end
 

data/lib/active_interactor/interactor/perform.rb

@@ -175,7 +175,11 @@ module ActiveInteractor
       #
       # @return [Base] a duplicated {Base interactor} instance
       def deep_dup
-        self.class.new(context.dup).with_options(options.dup)
+        dupped = dup
+        %w[@context @options].each do |variable|
+          dupped.instance_variable_set(variable, instance_variable_get(variable)&.dup)
+        end
+        dupped
       end
 
       # Options for the {Base interactor} {#perform}

data/lib/active_interactor/models.rb

@@ -13,39 +13,21 @@ module ActiveInteractor
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 1.0.0
     module InstanceMethods
-      def initialize(attributes = nil)
-        copy_flags!(attributes) if attributes
-        copy_called!(attributes) if attributes
-        attributes_as_hash = context_attributes_as_hash(attributes)
-        super(attributes_as_hash)
-      end
-
-      # Merge an instance of model class into the calling model class instance
-      #
-      # @see Context::Attributes#merge!
-      #
-      # @param context [Class] a {Base context} instance to be merged
-      # @return [self] the {Base context} instance
-      def merge!(context)
-        copy_flags!(context)
-        context.each_pair do |key, value|
-          self[key] = value unless value.nil?
-        end
-        self
-      end
-
-      private
-
-      def context_attributes_as_hash(attributes)
-        return attributes.to_h if attributes&.respond_to?(:to_h)
-        return attributes.attributes.to_h if attributes.respond_to?(:attributes)
+      def initialize(*)
+        @attributes = self.class._default_attributes&.deep_dup
+        super
       end
     end
 
     # Include methods needed for a {Context::Base context} class to function properly.
     #
+    # @note You must include ActiveModel::Model and ActiveModel::Attributes or a similar implementation for
+    #  the object to function properly.
+    #
     # @example
     #   class User
+    #     include ActiveModel::Model
+    #     include ActiveModel::Attributes
     #     extend ActiveInteractor::Models
     #     acts_as_context
     #   end
@@ -55,9 +37,12 @@ module ActiveInteractor
     #   end
     def acts_as_context
       class_eval do
-        include ActiveModel::Validations
-        include ActiveInteractor::Models::InstanceMethods
+        extend ActiveInteractor::Context::Attributes::ClassMethods
+
+        include ActiveInteractor::Context::Attributes
+        include ActiveInteractor::Context::Errors
         include ActiveInteractor::Context::Status
+        include ActiveInteractor::Models::InstanceMethods
         delegate :each_pair, to: :attributes
       end
     end

data/lib/active_interactor/organizer/interactor_interface.rb

@@ -40,7 +40,7 @@ module ActiveInteractor
       #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
       # @return [InteractorInterface] a new instance of {InteractorInterface}
       def initialize(interactor_class, options = {})
-        @interactor_class = interactor_class.to_s.classify.safe_constantize
+        @interactor_class = interactor_class.to_s.camelize.safe_constantize
         @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
         @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) }
       end

data/lib/active_interactor/organizer/interactor_interface_collection.rb

@@ -14,6 +14,7 @@ module ActiveInteractor
     #  @return [Array<InteractorInterface>] the {InteractorInterface} collection
     class InteractorInterfaceCollection
       attr_reader :collection
+
       # @!method map(&block)
       #  Invokes the given block once for each element of {#collection}.
       #  @return [Array] a new array containing the values returned by the block.

data/lib/active_interactor/rails/orm/dynamoid.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'dynamoid/document'
+
+Dynamoid::Document::ClassMethods.include ActiveInteractor::Models

data/lib/active_interactor/rails/orm/mongoid.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ActiveSupport.on_load(:mongoid) do
+  Mongoid::Document::ClassMethods.include ActiveInteractor::Models
+end

data/lib/active_interactor/version.rb

@@ -3,5 +3,5 @@
 module ActiveInteractor
   # The ActiveInteractor version
   # @return [String] the ActiveInteractor version
-  VERSION = '1.0.0'
+  VERSION = '1.0.5'
 end

data/lib/rails/generators/templates/organizer.erb

@@ -6,8 +6,8 @@ class <%= class_name %> < ApplicationOrganizer
 
 <%- end -%>
 <%- if interactors.any? -%>
-  organize <%= interactors.map(&:classify).join(", ") %>
+  organize <%= interactors.join(", ") %>
 <%- else -%>
-  # organize Interactor1, Interactor2
+  # organize :interactor_1, :interactor_2
 <%- end -%>
 end

data/spec/active_interactor/base_spec.rb

@@ -27,6 +27,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { 'PlaceData' }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
 
       context 'when passed as a symbol' do
@@ -36,6 +47,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { :place_data }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
 
       context 'when passed as a constant' do
@@ -45,6 +67,17 @@ RSpec.describe ActiveInteractor::Base do
           subject
           expect(described_class.context_class).to eq TestContext
         end
+
+        # https://github.com/aaronmallen/activeinteractor/issues/168
+        context 'when singularized' do
+          let!(:singularized_class) { build_context('PlaceData') }
+          let(:klass) { PlaceData }
+
+          it 'is expected to assign the appropriate context class' do
+            subject
+            expect(described_class.context_class).to eq PlaceData
+          end
+        end
       end
     end
   end

data/spec/active_interactor/context/base_spec.rb

@@ -3,34 +3,113 @@
 require 'spec_helper'
 
 RSpec.describe ActiveInteractor::Context::Base do
-  after(:each) { described_class.instance_variable_set('@__attributes', []) }
-
-  describe '#attributes' do
+  describe '.attributes' do
     context 'when no arguments are passed' do
-      subject { described_class.attributes }
+      subject { context_class.attributes }
+      let!(:context_class) { build_context }
       it { is_expected.to eq [] }
 
       context 'when an attribute :foo was previously defined' do
-        before { described_class.instance_variable_set('@__attributes', %i[foo]) }
+        let!(:context_class) do
+          build_context do
+            attributes :foo
+          end
+        end
 
         it { is_expected.to eq %i[foo] }
       end
     end
 
     context 'when given arguments :foo and :bar' do
-      subject { described_class.attributes(:foo, :bar) }
+      subject { context_class.attributes(:foo, :bar) }
+      let!(:context_class) { build_context }
 
       it { is_expected.to eq %i[bar foo] }
 
       context 'when an attribute :foo was previously defined' do
-        before { described_class.instance_variable_set('@__attributes', %i[foo]) }
+        before { TestContext.attributes(:foo) }
 
         it { is_expected.to eq %i[bar foo] }
       end
     end
   end
 
-  describe '.attributes' do
+  describe '#[]' do
+    subject { instance[attribute] }
+
+    context 'with class attributes []' do
+      let(:instance) { build_context.new }
+
+      context 'with attribute nil' do
+        let(:attribute) { :foo }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'with attribute equal to "foo"' do
+        let(:attribute) { :foo }
+        before { instance.foo = 'foo' }
+
+        it { is_expected.to eq 'foo' }
+      end
+    end
+
+    context 'with class attributes [:foo]' do
+      let!(:context_class) do
+        build_context do
+          attributes :foo
+        end
+      end
+      let(:instance) { context_class.new }
+
+      context 'with attribute nil' do
+        let(:attribute) { :foo }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'with attribute equal to "foo"' do
+        let(:attribute) { :foo }
+        before { instance.foo = 'foo' }
+
+        it { is_expected.to eq 'foo' }
+      end
+    end
+  end
+
+  describe '#attribute?' do
+    subject { instance.attribute?(attribute) }
+
+    context 'with class attributes []' do
+      let(:instance) { build_context.new }
+      let(:attribute) { :foo }
+
+      it { is_expected.to eq false }
+    end
+
+    context 'with class attributes [:foo]' do
+      let!(:context_class) do
+        build_context do
+          attributes :foo
+        end
+      end
+      let(:instance) { context_class.new }
+
+      context 'checking attribute :foo' do
+        let(:attribute) { :foo }
+
+        it { is_expected.to eq true }
+      end
+
+      context 'checking attribute :bar' do
+        let(:attribute) { :bar }
+
+        it { is_expected.to eq false }
+      end
+    end
+  end
+
+  describe '#attributes' do
     subject { instance.attributes }
 
     context 'with class attributes []' do
@@ -43,13 +122,23 @@ RSpec.describe ActiveInteractor::Context::Base do
     end
 
     context 'with class attributes [:foo, :bar, :baz]' do
-      before { described_class.attributes(:foo, :bar, :baz) }
+      before { build_context.attributes(:foo, :bar) }
+
+      context 'with an instance having attributes { :foo => "foo", :bar => "bar" }' do
+        let(:instance) { TestContext.new(foo: 'foo', bar: 'bar') }
+
+        it { is_expected.to be_a Hash }
+        it { is_expected.to eq(bar: 'bar', foo: 'foo') }
+      end
 
       context 'with an instance having attributes { :foo => "foo", :bar => "bar", :baz => "baz" }' do
-        let(:instance) { described_class.new(foo: 'foo', bar: 'bar', baz: 'baz') }
+        let(:instance) { TestContext.new(foo: 'foo', bar: 'bar', baz: 'baz') }
 
         it { is_expected.to be_a Hash }
-        it { is_expected.to eq(bar: 'bar', baz: 'baz', foo: 'foo') }
+        it { is_expected.to eq(bar: 'bar', foo: 'foo') }
+        it 'is expected to assign :baz' do
+          expect(instance.baz).to eq 'baz'
+        end
       end
     end
   end
@@ -81,7 +170,7 @@ RSpec.describe ActiveInteractor::Context::Base do
       it { expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure) }
 
       it 'is expected not to merge errors' do
-        expect(instance.errors).not_to receive(:merge!)
+        expect(instance.errors).not_to receive(:merge!).with(nil)
         subject
       rescue ActiveInteractor::Error::ContextFailure # rubocop:disable Lint/SuppressedException
       end