actioninteractor 0.0.17.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b81aa835686296262195e571d9fb8d1236843347c3ca5122aab1e0811cb6e91
-  data.tar.gz: adcd0dd458f3060e867f551f91675486f9cdb7d45da1542b7b0cce70d6dc2efa
+  metadata.gz: fbd574e879d9fab318f41cc0f07eebdaaefc8e05327c7bb2372a85d34764d685
+  data.tar.gz: 1f7db0bf258fa20186e9191e4935c500c0c99fd9de319393b1d2d3651e12c0ad
 SHA512:
-  metadata.gz: 5e9fb543029fe26df807969abfc770b5b5f7488fe36c92bb097e85dbfbfca75ca0b87016197327fcb05c652a411ff4311bff4962ca3ea2410dc0b63632a13efe
-  data.tar.gz: 99367f92a0eef0f35e47c3f12dfd1fc1ea32ca0e03d0d80df1eb4656c6f2f214677b5d14b1f0cdda5d16663571279fc6c1842a74c47d8eca76e1329686e52137
+  metadata.gz: 51f6b4f5e7740e49083f9895c9c799486a88aad1dbaeb310573ba3a82e22aa25cfc2e5e9dc9112bc9214f87f200a3ea885a4f0b895330a3aa424688fc79812b8
+  data.tar.gz: 5f43085d1442d8ad88f365746c276e907fa90b6b645c47df9fe851507fe3778c776c73a10c558f703dd87c3941c843ffc906c214493c0379353dd8fae2e64e7f

data/actioninteractor.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |s|
 
   s.add_dependency "bundler", ">= 1.3"
   s.add_development_dependency "rake", "~> 0"
+  s.add_development_dependency "test-unit", ">= 3.3"
 end

data/lib/action_interactor/base.rb

@@ -1,77 +1,118 @@
 # frozen_string_literal: true
 
 module ActionInteractor
+  # == Action \Interactor \Base
+  #
+  # This is a base class for an interactor (data processing unit).
+  # It gets a payload (input) as an initialization parameter and
+  # execute some methods which is described in `execute` method.
+  # After that, the results can be obtained by `results` method.
+  # In Ruby on Rails, it can be used for doing some business logic
+  # like new user registration process. For example inserting user data
+  # in the database and creating a notification message, registering a
+  # job for sending the message.
+  #
+  # class RegistrationInteractor < ActionInteractor::Base
+  #   def execute
+  #     return fail! unless payload[:name]
+  #     user = User.create!(name: payload[:name])
+  #     notiticaion = user.notifications.create!(name: 'Welcome')
+  #     RegistrationNotificationJob.perform_later!
+  #     results.add(:user, user)
+  #     success!
+  #   end
+  # end
   class Base
-    attr_reader :params, :results
+    attr_reader :payload, :errors, :results
 
-    def initialize(params)
-      @params = params
+    # 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!
     end
 
+    # Execute the operation with given payload.
+    # (Should be overridden.)
     def execute
       # if the interactor already finished execution, do nothing.
       return if finished?
-      # if contract is not satisfied= (ex: params is empty), mark as failed.
-      return fail! if params.nil?
-      # implement some codes
+      # if contract is not satisfied= (ex: payload is empty), mark as failed.
+      return fail! if payload.nil?
+      # (Implement some codes for the operation.)
+
       # if finished execution, mark as success.
       success!
     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"))
     end
 
+    # Returns `true` if marked as finished otherwise `false`.
     def finished?
       @_finished
     end
 
+    # Returns `true` if not marked as finished otherwise `false`.
     def unfinished?
       !finished?
     end
 
+    # Returns `true` if marked as success and there are no errors otherwise `false`.
     def success?
-      @_success
+      @_success && @errors.empty?
     end
 
+    # Returns `true` if not marked as success or there are some errors otherwise `false`.
     def failure?
       !success?
     end
 
+    # Returns `true` if the operation was not successful and not finished otherwise `false`.
     def aborted?
       failure? && unfinished?
     end
 
+    # Reset statuses.
     def reset!
-      @results = Results.new
       @_success = false
       @_finished = false
     end
 
+    # Mark the operation as failed and unfinished.
     def abort!
       @_success = false
       @_finished = false
     end
 
+    # Mark the operation as success and finished.
     def success!
       @_success = true
       @_finished = true
     end
 
+    # Mask the operation as failed and finished.
     def fail!
       @_success = false
       @_finished = true
     end
 
     class << self
-      def execute(params)
-        new(params).tap(&:execute)
+      # Execute the operation with given payload.
+      def execute(payload)
+        new(payload).tap(&:execute)
       end
 
-      def execute!(params)
-        new(params).tap(&:execute!)
+      # Execute the operation with given payload.
+      # If there are some errors, ActionInteractor::ExeuctionError will be raised.
+      def execute!(payload)
+        new(payload).tap(&:execute!)
       end
     end
   end

data/lib/action_interactor/errors.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module ActionInteractor
+  # == Action \Interactor \Errors
+  # Provides a +Hash+ like object to Action Interactors execution errors.
+  class Errors
+    include Enumerable
+    extend Forwardable
+
+    attr_reader :errors
+
+    def_delegators :@errors, :clear, :keys, :values, :[], :empty?, :any?
+
+    def initialize(*)
+      @errors = {}
+    end
+
+    # Add +error+ to the errors hash.
+    def add(attribute, error)
+      errors[attribute.to_sym] = error
+    end
+
+    # Delete a error for +key+.
+    def delete(key)
+      attribute = key.to_sym
+      errors.delete(attribute)
+    end
+
+    # Iterates through each error key, value pair in the errors hash.
+    def each
+      errors.each_key do |attribute|
+        yield attribute, errors[attribute]
+      end
+    end
+
+    # Convert errors to hash.
+    def to_hash
+      errors
+    end
+
+    # Returns array containing error messages.
+    def messages
+      errors.map do |attribute, error|
+        "#{attribute} #{error}"
+      end
+    end
+  end
+end

data/lib/action_interactor/results.rb

@@ -3,20 +3,46 @@
 require "forwardable"
 
 module ActionInteractor
+  # == Action \Interactor \Results
+  # Provides a +Hash+ like object to Action Interactors execution results.
   class Results
     include Enumerable
     extend Forwardable
 
-    attr_reader :_results
+    attr_reader :results
 
-    def_delegators :@_results, :clear, :keys, :values, :[], :delete
+    def_delegators :@results, :clear, :keys, :values, :[]
 
     def initialize(*)
-      @_results = {}
+      @results = {}
     end
 
-    def add(attribute, detail)
-      _results[attribute.to_sym] = detail
+    # Add +result+ to the results hash.
+    def add(attribute, result)
+      results[attribute.to_sym] = result
+    end
+
+    # Delete a result for +key+.
+    def delete(key)
+      attribute = key.to_sym
+      results.delete(attribute)
+    end
+
+    # Iterates through each result key, value pair in the results hash.
+    def each
+      results.each_key do |attribute|
+        yield attribute, results[attribute]
+      end
+    end
+
+    def method_missing(attribute, *)
+      # Define shortcut methods for each result key.
+      # It returns the result for the key
+      if results.has_key?(attribute)
+        results[attribute]
+      else
+        super
+      end
     end
   end
 end

data/lib/actioninteractor.rb

@@ -4,5 +4,6 @@ $:.unshift File.dirname(__FILE__)
 
 module ActionInteractor
   autoload :Base, "action_interactor/base"
+  autoload :Errors, "action_interactor/errors"
   autoload :Results, "action_interactor/results"
 end

data/test/base_test.rb

@@ -2,44 +2,52 @@ require "test/unit"
 require_relative "../lib/actioninteractor"
 
 class BaseTest < Test::Unit::TestCase
+  test "initialized successfully" do
+    payload = {}
+    interactor = ActionInteractor::Base.new(payload)
+    assert_equal(interactor.success?, false)
+    assert_equal(interactor.finished?, false)
+    assert_equal(interactor.errors.empty?, true)
+  end
+
   test ".execute does not raise error" do
-    params = {}
-    assert_nothing_raised { ActionInteractor::Base.execute(params) }
+    payload = {}
+    assert_nothing_raised { ActionInteractor::Base.execute(payload) }
   end
 
   test ".execute returns an ActionInteractor::Base instance" do
-    params = {}
-    interactor = ActionInteractor::Base.execute(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
     assert_instance_of(ActionInteractor::Base, interactor)
   end
 
   test ".execute! also returns an ActionInteractor::Base instance" do
-    params = {}
-    interactor = ActionInteractor::Base.execute!(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute!(payload)
     assert_instance_of(ActionInteractor::Base, interactor)
   end
 
   test "the result is an instance of ActionInteractor::Results" do
-    params = {}
-    interactor = ActionInteractor::Base.execute(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
     assert_instance_of(ActionInteractor::Results, interactor.results)
   end
 
   test "#success? is true" do
-    params = {}
-    interactor = ActionInteractor::Base.execute(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
     assert interactor.success?
   end
 
   test "#finished? is true" do
-    params = {}
-    interactor = ActionInteractor::Base.execute(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
     assert interactor.finished?
   end
 
   test "#aborted? is true after #abort!" do
-    params = {}
-    interactor = ActionInteractor::Base.execute(params)
+    payload = {}
+    interactor = ActionInteractor::Base.execute(payload)
     interactor.abort!
     assert interactor.aborted?
   end

data/test/errors_test.rb

@@ -0,0 +1,35 @@
+require "test/unit"
+require_relative "../lib/actioninteractor"
+
+class ErrorsTest < Test::Unit::TestCase
+  test "initialized correctly" do
+    assert_nothing_raised { ActionInteractor::Errors.new }
+  end
+
+  test "add result for the key" do
+    errors = ActionInteractor::Errors.new
+    errors.add(:foo, "bar")
+    assert_equal(errors[:foo], "bar")
+  end
+
+  test "delete the result for the key" do
+    errors = ActionInteractor::Errors.new
+    errors.add(:foo, "bar")
+    errors.delete(:foo)
+    assert_equal(errors[:foo], nil)
+  end
+
+  test "iterate through the errors" do
+    errors = ActionInteractor::Errors.new
+    errors.add(:foo, "foo")
+    errors.add(:bar, "bar")
+    errors.add(:baz, "baz")
+    info = []
+    errors.each do |attribute, result|
+      info << [attribute, result]
+    end
+    assert_equal(info[0], [:foo, "foo"])
+    assert_equal(info[1], [:bar, "bar"])
+    assert_equal(info[2], [:baz, "baz"])
+  end
+end

data/test/inheritance_test.rb

@@ -4,24 +4,29 @@ require_relative "../lib/actioninteractor"
 class User
   attr_accessor :name
 
-  def initialize(params)
-    @name = params[:name]
+  def initialize(payload)
+    @name = payload[:name]
   end
 end
 
 class RegistrationInteractor < ActionInteractor::Base
   def execute
-    return fail! unless params[:name]
-    results.add(:user, User.new(name: params[:name]))
+    unless payload[:name]
+      errors.add(:name, "can't be blank.")
+      return fail!
+    end
+    results.add(:user, User.new(name: payload[:name]))
     success!
   end
 end
 
 class NotificationInteractor < ActionInteractor::Base
   def execute
-    return fail! unless params[:name] || params[:email]
-    results.add(:name, params[:name])
-    results.add(:email, params[:email])
+    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?
+    results.add(:name, payload[:name])
+    results.add(:email, payload[:email])
     success!
   end
 end
@@ -29,82 +34,100 @@ end
 
 class InheritanceTest < Test::Unit::TestCase
   test ".execute does not raise error" do
-    params = { name: 'John'}
-    assert_nothing_raised { RegistrationInteractor.execute(params) }
+    payload = { name: 'John'}
+    assert_nothing_raised { RegistrationInteractor.execute(payload) }
   end
 
   test ".execute returns an RegistrationInteractor instance" do
-    params = { name: 'John'}
-    interactor = RegistrationInteractor.execute(params)
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.execute(payload)
     assert_instance_of(RegistrationInteractor, interactor)
   end
 
   test "the result contains a user" do
-    params = { name: 'John'}
-    interactor = RegistrationInteractor.execute(params)
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.execute(payload)
     assert_instance_of(User, interactor.results[:user])
   end
 
   test "the result user name is John" do
-    params = { name: 'John'}
-    interactor = RegistrationInteractor.execute(params)
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.execute(payload)
     user = interactor.results[:user]
     assert_equal(user.name, 'John')
   end
 
   test "#success? is true" do
-    params = { name: 'John'}
-    interactor = RegistrationInteractor.execute(params)
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.execute(payload)
     assert interactor.success?
   end
 
   test "#finished? is true" do
-    params = { name: 'John'}
-    interactor = RegistrationInteractor.execute(params)
+    payload = { name: 'John'}
+    interactor = RegistrationInteractor.execute(payload)
     assert interactor.finished?
   end
 
-  test "if params is empty, .execute returns instance of RegistrationInteractor" do
-    params = {}
-    interactor = RegistrationInteractor.execute(params)
+  test "if payload is empty, .execute returns instance of RegistrationInteractor" do
+    payload = {}
+    interactor = RegistrationInteractor.execute(payload)
     assert_instance_of(RegistrationInteractor, interactor)
   end
 
-  test "if params is empty, #execute! raises a ExecutionError" do
-    params = {}
-    interactor = RegistrationInteractor.new(params)
+  test "if payload is empty, #execute! raises a ExecutionError" do
+    payload = {}
+    interactor = RegistrationInteractor.new(payload)
     error = assert_raises ActionInteractor::ExecutionError do
       interactor.execute!
     end
     assert_equal "Failed to execute the interactor", error.message
   end
 
-  test "if params is empty, #execute! raises a ExecutionError" do
-    params = {}
-    error = assert_raises ActionInteractor::ExecutionError do
-      RegistrationInteractor.execute!(params)
-    end
-    assert_equal "Failed to execute the interactor", error.message
-  end
-
-  test "if params is empty, #failure? is true" do
-    params = {}
-    interactor = RegistrationInteractor.execute(params)
+  test "if payload is empty, #failure? is true" do
+    payload = {}
+    interactor = RegistrationInteractor.execute(payload)
     assert interactor.failure?
   end
 
-  test "if params is empty, #finished? is true" do
-    params = {}
-    interactor = RegistrationInteractor.execute(params)
+  test "if payload is empty, #finished? is true" do
+    payload = {}
+    interactor = RegistrationInteractor.execute(payload)
     assert interactor.finished?
   end
 
   test "the result user name is Taro and email is taro@example.com" do
-    params = { name: 'Taro', email: 'taro@example.com'}
-    interactor = NotificationInteractor.execute(params)
+    payload = { name: 'Taro', email: 'taro@example.com'}
+    interactor = NotificationInteractor.execute(payload)
     name = interactor.results[:name]
     assert_equal(name, 'Taro')
     email = interactor.results[:email]
     assert_equal(email, 'taro@example.com')
   end
+
+  test "if none is given, the registration and notification will fail." do
+    payload = {}
+    registration = RegistrationInteractor.execute(payload)
+    assert registration.failure?
+    assert registration.errors.any?
+    assert_equal(registration.errors.to_hash, { name: "can't be blank." })
+    assert_equal(registration.errors.messages, ["name can't be blank."])
+    notification = NotificationInteractor.execute(payload)
+    assert notification.failure?
+    assert notification.errors.any?
+    assert_equal(notification.errors.to_hash, { name: "can't be blank.", email: "can't be blank." })
+    assert_equal(notification.errors.messages, ["name can't be blank.", "email can't be blank."])
+  end
+
+  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.errors.empty?
+    notification = NotificationInteractor.execute(payload)
+    assert notification.failure?
+    assert notification.errors.any?
+    assert_equal(notification.errors.to_hash, { email: "can't be blank." })
+    assert_equal(notification.errors.messages, ["email can't be blank."])
+  end
 end

data/test/results_test.rb

@@ -11,4 +11,34 @@ class ResultsTest < Test::Unit::TestCase
     results.add(:foo, "bar")
     assert_equal(results[:foo], "bar")
   end
+
+  test "delete the result for the key" do
+    results = ActionInteractor::Results.new
+    results.add(:foo, "bar")
+    results.delete(:foo)
+    assert_equal(results[:foo], nil)
+  end
+
+  test "iterate through the results" do
+    results = ActionInteractor::Results.new
+    results.add(:foo, "foo")
+    results.add(:bar, "bar")
+    results.add(:baz, "baz")
+    info = []
+    results.each do |attribute, result|
+      info << [attribute, result]
+    end
+    assert_equal(info[0], [:foo, "foo"])
+    assert_equal(info[1], [:bar, "bar"])
+    assert_equal(info[2], [:baz, "baz"])
+  end
+
+  test "get result by the key name's method" do
+    results = ActionInteractor::Results.new
+    assert_raises ::NoMethodError do
+      results.foo
+    end
+    results.add(:foo, "bar")
+    assert_equal(results.foo, "bar")
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actioninteractor
 version: !ruby/object:Gem::Version
-  version: 0.0.17.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryo Hashimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-25 00:00:00.000000000 Z
+date: 2020-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
 description: Action Interactor provides a simple interface for performing operations
   like Service Object / Command pattern.
 email: ryohashimoto@gmail.com
@@ -48,9 +62,11 @@ files:
 - Rakefile
 - actioninteractor.gemspec
 - lib/action_interactor/base.rb
+- lib/action_interactor/errors.rb
 - lib/action_interactor/results.rb
 - lib/actioninteractor.rb
 - test/base_test.rb
+- test/errors_test.rb
 - test/inheritance_test.rb
 - test/results_test.rb
 homepage: https://github.com/ryohashimoto/lightrails
@@ -79,5 +95,6 @@ summary: Action Interactor provides a simple interface for performing operations
   of Lightrails).
 test_files:
 - test/base_test.rb
+- test/errors_test.rb
 - test/inheritance_test.rb
 - test/results_test.rb