actioninteractor 0.1.0.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2204c4f56ead70dd52e32bf5a656a2421c5b85e7de1ceec6d43caa7446ae9866
-  data.tar.gz: a915d6983916e0a41b12fc65806fae06e0e76c6a4dbce3a1e907de519ecc7b7f
+  metadata.gz: 6482218b9fe304483abc4ae16d38e51c8de0cd6b9fe9c1155caaca1bff6a660c
+  data.tar.gz: 98db252d344409893580173b7f982419db14986a598e7b772eba8bca22ce5ed6
 SHA512:
-  metadata.gz: 6d41987911103f961d7286fd4b57cf55ba646e4021bf98361dd9962691ff9cecd780896f65cf3a02318a3bb5d01915037d6ef524093251fcf193d6a5df5b53ae
-  data.tar.gz: 44eae8fdacf7ff12e16e93178acec405db9178f1f8394ee2f6a140d152a433a97e5ef7c0ac8e20155cddc1de7ae4e5521876faf12230f2257a260746e1982b6a
+  metadata.gz: bb962e73b235f0ebe37c906d00904ee71e1efce001eeef1d3e756317c9994cc2473443629b538451c25024aeb6b6fe949b0542f0a5c324aeb92fa4fe10e9377b
+  data.tar.gz: 6fa15f43b82685f294d5e63a5a01fdde4775cae10405c99023c48aa698ce79da9dc7ba246a337221869037e17bd9e7e8031a07ef83c2e74eb4ab1ef6d66a027d

data/lib/action_interactor/base.rb

@@ -14,24 +14,25 @@ module ActionInteractor
   #
   # class RegistrationInteractor < ActionInteractor::Base
   #   def execute
-  #     return fail! unless payload[:name]
+  #     return failure! unless payload[:name]
   #     user = User.create!(name: payload[:name])
   #     notiticaion = user.notifications.create!(name: 'Welcome')
   #     RegistrationNotificationJob.perform_later!
   #     results.add(:user, user)
-  #     success!
+  #     successful!
   #   end
   # end
   class Base
-    attr_reader :payload, :errors, :results
+    attr_reader :payload, :errors, :results, :state, :interactor_name
 
     # Initialize with payload
     # Errors and Results data and initial state will be set.
     def initialize(payload)
       @payload = payload
-      @errors = Errors.new
-      @results = Results.new
-      reset!
+      @errors = payload[:errors] || Errors.new
+      @results = payload[:results] || Results.new
+      @state = payload[:state] || ExecutionState.new
+      @interactor_name = payload[:interactor_name] || underscore(self.class.name)
     end
 
     # Execute the operation with given payload.
@@ -39,24 +40,24 @@ module ActionInteractor
     def execute
       # if the interactor already finished execution, do nothing.
       return if finished?
-      # if contract is not satisfied= (ex: payload is empty), mark as failed.
-      return fail! if payload.nil?
+      # if contract is not satisfied= (ex: payload is empty), mark as failure.
+      return failure! if payload.nil?
       # (Implement some codes for the operation.)
 
-      # if finished execution, mark as success.
-      success!
+      # if finished execution, mark as successful.
+      successful!
     end
 
     # Execute the operation with given payload.
     # If there are some errors, ActionInteractor::ExeuctionError will be raised.
     def execute!
       execute
-      success? || raise(ExecutionError.new("Failed to execute the interactor"))
+      successful? || raise(ExecutionError.new("Failed to execute the interactor"))
     end
 
     # Returns `true` if marked as finished otherwise `false`.
     def finished?
-      @_finished
+      state.successful? || state.failure?
     end
 
     # Returns `true` if not marked as finished otherwise `false`.
@@ -65,44 +66,46 @@ module ActionInteractor
     end
 
     # Returns `true` if marked as success and there are no errors otherwise `false`.
-    def success?
-      @_success && @errors.empty?
+    def successful?
+      state.successful? && @errors.empty?
     end
 
+    alias_method :success?, :successful?
+
     # Returns `true` if not marked as success or there are some errors otherwise `false`.
     def failure?
-      !success?
+      !successful?
     end
 
     # Returns `true` if the operation was not successful and not finished otherwise `false`.
     def aborted?
-      failure? && unfinished?
+      state.aborted?
     end
 
     # Reset statuses.
     def reset!
-      @_success = false
-      @_finished = false
+      @state = State.new
     end
 
-    # Mark the operation as failed and unfinished.
+    # Mark the operation as aborted.
     def abort!
-      @_success = false
-      @_finished = false
+      state.aborted!
     end
 
-    # Mark the operation as success and finished.
-    def success!
-      @_success = true
-      @_finished = true
+    # Mark the operation as successful.
+    def successful!
+      state.successful!
     end
 
-    # Mask the operation as failed and finished.
-    def fail!
-      @_success = false
-      @_finished = true
+    alias_method :success!, :successful!
+
+    # Mask the operation as failure.
+    def failure!
+      state.failure!
     end
 
+    alias_method :fail!, :failure!
+
     class << self
       # Execute the operation with given payload.
       def execute(payload)
@@ -115,6 +118,16 @@ module ActionInteractor
         new(payload).tap(&:execute!)
       end
     end
+
+    private
+
+    def underscore(name)
+      name.gsub(/::/, "__")
+          .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+          .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+          .tr("-", "_")
+          .downcase
+    end
   end
 
   class ExecutionError < StandardError; end

data/lib/action_interactor/composite.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActionInteractor
+  class Composite < Base
+    # == Action \Interactor \Composite
+    #
+    # An interactor class which containing multiple interactors
+    # using the composite pattern.
+    #
+    # It can be used for execute multiple operations and it will be
+    # marked as successful if all operations executed successful.
+    # (otherwise it will be marked as failure.)
+    attr_reader :interactors
+
+    # Initialize with payload and an array for containing interactors.
+    def initialize(payload)
+      super
+      @interactors = []
+    end
+
+    # Execute containing interactors' `execute` method with given payload.
+    def execute
+      return if finished?
+      return failure! if payload.nil?
+
+      interactors.each_with_index do |interactor, index|
+        execute_sub_interactor(interactor, index)
+        return failure! if interactor.failure?
+      end
+
+      successful!
+    end
+
+    # Add an interactor to the interactors array.
+    def add(interactor)
+      interactors << interactor
+    end
+
+    # Delete the interactor from the interactors array.
+    def delete(interactor)
+      interactors.delete(interactor)
+    end
+
+    private
+
+    def execute_sub_interactor(interactor, index)
+      interactor.execute
+      if interactor.successful?
+        interactor.results.each_pair do |attr_name, value|
+          results.add(sub_attr_key(interactor, index, attr_name), value)
+        end
+      else interactor.failure?
+        interactor.errors.each_pair do |attr_name, value|
+          errors.add(sub_attr_key(interactor, index, attr_name), value)
+        end
+      end
+    end
+
+    def sub_attr_key(interactor, index, attr_name)
+      "#{interactor.interactor_name}_#{index}__#{attr_name}".to_sym
+    end
+  end
+end

data/lib/action_interactor/errors.rb

@@ -11,7 +11,7 @@ module ActionInteractor
 
     attr_reader :errors
 
-    def_delegators :@errors, :clear, :keys, :values, :[], :empty?, :any?
+    def_delegators :@errors, :clear, :keys, :values, :[], :empty?, :any?, :each_pair
 
     def initialize(*)
       @errors = {}

data/lib/action_interactor/execution_state.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActionInteractor
+  # == Action \Interactor \Execution \State
+  #
+  # State machine used in `ActionInteractor::Base`
+  class ExecutionState < State
+    # Define default states
+    STATES = [
+      :initial,    # Initial state
+      :processing, # The operation is processing
+      :successful, # The operation is finished successfully
+      :failure,    # The operation is failed
+      :aborted,    # The operation is aborted
+    ]
+
+    # Define default transitions
+    # key: target state, value: original states
+    TRANSITIONS = {
+      initial: [:processing],
+      processing: [:initial],
+      successful: [:initial, :processing],
+      failure: [:initial, :processing],
+      aborted: [:initial, :processing],
+    }
+  end
+end

data/lib/action_interactor/results.rb

@@ -11,7 +11,7 @@ module ActionInteractor
 
     attr_reader :results
 
-    def_delegators :@results, :clear, :keys, :values, :[]
+    def_delegators :@results, :clear, :keys, :values, :[], :empty?, :any?, :each, :each_pair
 
     def initialize(*)
       @results = {}

data/lib/action_interactor/state.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActionInteractor
+  # == Action \Interactor \State
+  #
+  # Simple state machine for general purpose.
+  # You can declare STATES / TRANSITIONS in subclasses for
+  # customizing the behavior.
+  # See also `ActionInteractor::ExecutionState`
+  class State
+    # Define default states
+    STATES = [:initial, :finished]
+
+    # Define default transitions
+    # key: target state, value: original states
+    TRANSITIONS = {
+      finished: [:initial]
+    }
+
+    attr_reader :state
+
+    def initialize(initial_state=nil)
+      @state = initial_state || default_state
+    end
+
+    # Default initial state
+    # (You can override in subclasses.)
+    def default_state
+      :initial
+    end
+
+    # Returns true if transition to target_state from current state
+    def valid_transition?(target_state)
+      transitions[target_state].include?(state)
+    end
+
+    # Available states for the instance
+    def states
+      self.class.states
+    end
+
+    # Avaiolable transitions for the instance's states
+    def transitions
+      self.class.transitions
+    end
+
+    # Available states for the class
+    def self.states
+      self::STATES
+    end
+
+    # Available transitions for the class
+    def self.transitions
+      self::TRANSITIONS
+    end
+
+    def method_missing(method_name, *args)
+      name = method_name.to_s
+      # Returns true if state_name is the same as current state
+      if status_method_with_suffix?(name, "?")
+        return state == name.chop.to_sym
+      end
+
+      # Set current state to the state_name, otherwise raises error
+      if status_method_with_suffix?(name, "!")
+        state_name = name.chop.to_sym
+        unless valid_transition?(state_name)
+          raise TransitionError.new("Could not change state :#{state_name} from :#{state}")
+        end
+        @state = state_name
+        return
+      end
+
+      super
+    end
+
+    private
+
+    def status_method_with_suffix?(method_name, suffix)
+      return false unless method_name.end_with?(suffix)
+      states.include?(method_name.chop.to_sym)
+    end
+
+    # Error for invalid transitions
+    class TransitionError < StandardError; end
+  end
+end

data/lib/actioninteractor.rb

@@ -6,4 +6,7 @@ module ActionInteractor
   autoload :Base, "action_interactor/base"
   autoload :Errors, "action_interactor/errors"
   autoload :Results, "action_interactor/results"
+  autoload :State, "action_interactor/state"
+  autoload :ExecutionState, "action_interactor/execution_state"
+  autoload :Composite, "action_interactor/composite"
 end

data/test/base_test.rb

@@ -33,7 +33,13 @@ class BaseTest < Test::Unit::TestCase
     assert_instance_of(ActionInteractor::Results, interactor.results)
   end
 
-  test "#success? is true" do
+  test "#successful? is true" do
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
+    assert interactor.successful?
+  end
+
+  test "#success? (alias) is true" do
     payload = {}
     interactor = ActionInteractor::Base.execute(payload)
     assert interactor.success?
@@ -47,7 +53,7 @@ class BaseTest < Test::Unit::TestCase
 
   test "#aborted? is true after #abort!" do
     payload = {}
-    interactor = ActionInteractor::Base.execute(payload)
+    interactor = ActionInteractor::Base.new(payload)
     interactor.abort!
     assert interactor.aborted?
   end

data/test/composite_test.rb

@@ -0,0 +1,92 @@
+require "test/unit"
+require_relative "../lib/actioninteractor"
+
+class ChiefInteractor < ActionInteractor::Composite
+end
+
+class CookInteractor < ActionInteractor::Base
+  def execute
+    results.add(:steak, "Juicy beaf steak")
+    successful!
+  end
+end
+
+class ArrangeInteractor < ActionInteractor::Base
+  attr_reader :broken_dish
+
+  def initialize(payload)
+    super
+    @broken_dish = payload[:broken_dish].nil? ? false : payload[:broken_dish]
+  end
+
+  def execute
+    if broken_dish
+      errors.add(:dish, "Broken dish")
+      failure!
+    else
+      successful!
+    end
+  end
+end
+
+
+class CompositeTest < Test::Unit::TestCase
+  test "initialized successfully" do
+    payload = {}
+    interactor = ActionInteractor::Composite.new(payload)
+    assert_equal(interactor.success?, false)
+    assert_equal(interactor.finished?, false)
+    assert_equal(interactor.errors.empty?, true)
+  end
+
+  test "add interactors" do
+    payload = {}
+    chief_interactor = ChiefInteractor.new(payload)
+    cook_interactor = CookInteractor.new(interactor_name: "cook")
+    arrange_interactor = ArrangeInteractor.new(interactor_name: "arrange")
+    chief_interactor.add(cook_interactor)
+    chief_interactor.add(arrange_interactor)
+    interactor_names = chief_interactor.interactors.map(&:interactor_name)
+    assert_equal(interactor_names, %w[cook arrange])
+  end
+
+  test "remove interactor" do
+    payload = {}
+    chief_interactor = ChiefInteractor.new(payload)
+    cook_interactor = CookInteractor.new(interactor_name: "cook")
+    arrange_interactor = ArrangeInteractor.new(interactor_name: "arrange")
+    chief_interactor.add(cook_interactor)
+    chief_interactor.add(arrange_interactor)
+    chief_interactor.delete(cook_interactor)
+    interactor_names = chief_interactor.interactors.map(&:interactor_name)
+    assert_equal(interactor_names, %w[arrange])
+  end
+
+  test "successful in executing all interactors" do
+    payload = {}
+    chief_interactor = ChiefInteractor.new(payload)
+    cook_interactor = CookInteractor.new(interactor_name: "cook")
+    arrange_interactor = ArrangeInteractor.new(interactor_name: "arrange")
+    chief_interactor.add(cook_interactor)
+    chief_interactor.add(arrange_interactor)
+    chief_interactor.execute
+    assert_equal(chief_interactor.successful?, true)
+    assert_equal(chief_interactor.results.keys, [:cook_0__steak])
+    assert_equal(chief_interactor.results[:cook_0__steak], "Juicy beaf steak")
+  end
+
+  test "failure in executing the last interactor" do
+    payload = {}
+    chief_interactor = ChiefInteractor.new(payload)
+    cook_interactor = CookInteractor.new(interactor_name: "cook")
+    arrange_interactor = ArrangeInteractor.new(interactor_name: "arrange", broken_dish: true)
+    chief_interactor.add(cook_interactor)
+    chief_interactor.add(arrange_interactor)
+    chief_interactor.execute
+    assert_equal(chief_interactor.successful?, false)
+    assert_equal(chief_interactor.results.keys, [:cook_0__steak])
+    assert_equal(chief_interactor.results[:cook_0__steak], "Juicy beaf steak")
+    assert_equal(chief_interactor.errors.keys, [:arrange_1__dish])
+    assert_equal(chief_interactor.errors[:arrange_1__dish], "Broken dish")
+  end
+end

data/test/execution_state_test.rb

@@ -0,0 +1,60 @@
+require "test/unit"
+require_relative "../lib/actioninteractor"
+
+class ExecutionStateTest < Test::Unit::TestCase
+  test "initialized correctly" do
+    assert_nothing_raised { ActionInteractor::ExecutionState.new }
+  end
+
+  test "initial state is :initial" do
+    state = ActionInteractor::ExecutionState.new
+    assert_equal(state.state, :initial)
+  end
+
+  test "default states are :initial, :processing, :successful and :failure" do
+    state = ActionInteractor::ExecutionState.new
+    assert_equal(state.states, [:initial, :processing, :successful, :failure, :aborted])
+  end
+
+  test "default transitions are defined correctly" do
+    state = ActionInteractor::ExecutionState.new
+    assert_equal(
+      state.transitions,
+      {
+        initial: [:processing],
+        processing: [:initial],
+        successful: [:initial, :processing],
+        failure: [:initial, :processing],
+        aborted: [:initial, :processing],
+      }
+    )
+  end
+
+  test "able to change state from :initial to :processing" do
+    state = ActionInteractor::ExecutionState.new
+    assert_equal(state.initial?, true)
+    state.processing!
+    assert_equal(state.processing?, true)
+  end
+
+  test "able to change state from :processing to :successful" do
+    state = ActionInteractor::ExecutionState.new(:processing)
+    state.successful!
+    assert_equal(state.successful?, true)
+  end
+
+  test "able to change state from :initial to :failure" do
+    state = ActionInteractor::ExecutionState.new(:initial)
+    state.failure!
+    assert_equal(state.failure?, true)
+  end
+
+  test "raise TransitionError when try to change state from :successful to :failure" do
+    state = ActionInteractor::ExecutionState.new(:successful)
+    assert_equal(state.valid_transition?(:failure), false)
+    error = assert_raises ActionInteractor::ExecutionState::TransitionError do
+      state.failure!
+    end
+    assert_equal("Could not change state :failure from :successful", error.message)
+  end
+end

data/test/inheritance_test.rb

@@ -13,10 +13,10 @@ class RegistrationInteractor < ActionInteractor::Base
   def execute
     unless payload[:name]
       errors.add(:name, "can't be blank.")
-      return fail!
+      return failure!
     end
     results.add(:user, User.new(name: payload[:name]))
-    success!
+    successful!
   end
 end
 
@@ -24,10 +24,10 @@ class NotificationInteractor < ActionInteractor::Base
   def execute
     errors.add(:name, "can't be blank.") unless payload[:name]
     errors.add(:email, "can't be blank.") unless payload[:email]
-    return fail! if errors.any?
+    return failure! if errors.any?
     results.add(:name, payload[:name])
     results.add(:email, payload[:email])
-    success!
+    successful!
   end
 end
 
@@ -38,6 +38,18 @@ class InheritanceTest < Test::Unit::TestCase
     assert_nothing_raised { RegistrationInteractor.execute(payload) }
   end
 
+  test "returns 'registration_interactor' as default interactor name" do
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.new(payload)
+    assert_equal('registration_interactor', interactor.interactor_name)
+  end
+
+  test "returns 'registration' as specified interactor name" do
+    payload = { name: 'John', interactor_name: 'registration' }
+    interactor = RegistrationInteractor.new(payload)
+    assert_equal('registration', interactor.interactor_name)
+  end
+
   test ".execute returns an RegistrationInteractor instance" do
     payload = { name: 'John'}
     interactor = RegistrationInteractor.execute(payload)
@@ -57,10 +69,10 @@ class InheritanceTest < Test::Unit::TestCase
     assert_equal(user.name, 'John')
   end
 
-  test "#success? is true" do
+  test "#successful? is true" do
     payload = { name: 'John'}
     interactor = RegistrationInteractor.execute(payload)
-    assert interactor.success?
+    assert interactor.successful?
   end
 
   test "#finished? is true" do
@@ -122,7 +134,7 @@ class InheritanceTest < Test::Unit::TestCase
   test "if only the name is given, the registration is successful but the notification is not." do
     payload = { name: 'Taro' }
     registration = RegistrationInteractor.execute(payload)
-    assert registration.success?
+    assert registration.successful?
     assert registration.errors.empty?
     notification = NotificationInteractor.execute(payload)
     assert notification.failure?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actioninteractor
 version: !ruby/object:Gem::Version
-  version: 0.1.0.1
+  version: 0.2.4
 platform: ruby
 authors:
 - Ryo Hashimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2021-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,11 +62,16 @@ files:
 - Rakefile
 - actioninteractor.gemspec
 - lib/action_interactor/base.rb
+- lib/action_interactor/composite.rb
 - lib/action_interactor/errors.rb
+- lib/action_interactor/execution_state.rb
 - lib/action_interactor/results.rb
+- lib/action_interactor/state.rb
 - lib/actioninteractor.rb
 - test/base_test.rb
+- test/composite_test.rb
 - test/errors_test.rb
+- test/execution_state_test.rb
 - test/inheritance_test.rb
 - test/results_test.rb
 homepage: https://github.com/ryohashimoto/lightrails
@@ -88,13 +93,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Action Interactor provides a simple interface for performing operations (part
   of Lightrails).
 test_files:
 - test/base_test.rb
+- test/composite_test.rb
 - test/errors_test.rb
+- test/execution_state_test.rb
 - test/inheritance_test.rb
 - test/results_test.rb