excom 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e2a4c4c2e30de13e0b49be35a9f54a798b902b5
-  data.tar.gz: c415fda36ef08ab72a157917717ab217a7033ae5
+  metadata.gz: 20f76b20a337404d2adaa57942d2939e15c7af7d
+  data.tar.gz: 12b63ebcbc418abf3065ac971a94b2c1242411e3
 SHA512:
-  metadata.gz: 36cbeb14f6e1c366446787ea8c5b7475197180dd30bd99d8842328cd20071db59cabefb8dd2c9c390addd4040e7588b5a9484509a433eb156b70a10ab5700db4
-  data.tar.gz: c5d76e81aff3acbda0f7c28059f20ae46f778b465771ab52b2bbc04b46116e218a045a7982a0a36aeb8ab88fdb00d4033ebd9e2ec9ef7acacdf1e216fe20d26d
+  metadata.gz: 89f21c5133b8e03630d339465f05dfc90854fef955d0ec71c0bb22c22c626494a2f314e257e961726a622a273ee5117e7253ae4395a7d33d4e8ad684ee95533e
+  data.tar.gz: 7e7bb287d15468f03481e4b49cc2a7897ec5b63675e2a918965c758b896f50b3498c04292581c49122433b99b8a008b9d586888d4f3a54de8dd5b751e0dd32ad

data/README.md

@@ -1,6 +1,6 @@
 # Excom
 
-Flexible and highly extensible Commands (Service Objects) for business logic.
+Flexible and highly extensible Service Objects for business logic organization.
 
 [![build status](https://secure.travis-ci.org/akuzko/excom.png)](http://travis-ci.org/akuzko/excom)
 [![github release](https://img.shields.io/github/release/akuzko/excom.svg)](https://github.com/akuzko/excom/releases)
@@ -21,26 +21,35 @@ Or install it yourself as:
 
     $ gem install excom
 
+## Preface
+
+`Excom` stands for **Ex**excutable **Com**and. Initially, `Excom::Command` was the main
+class, provided by the gem. But it seems that "Service" name become more popular and
+common for describing classes for business logic, so it was renamed in this gem too.
+
 ## Usage
 
-General idea behind every `excom` command is simple: each command can have arguments,
-options (named arguments), and should define `run` method that is called during
-command execution. Executed command has `status` and `result`.
+General idea behind every `excom` service is simple: each service can have arguments,
+options (named arguments), and should define `execute!` method that is called during
+service execution. Executed service has `status` and `result`.
 
-The **very basic usage** of `Excom` commands can be shown with following example:
+The very basic usage of `Excom` services can be shown with following example:
 
 ```rb
-# app/commands/todos/update.rb
+# app/services/todos/update.rb
 module Todos
-  class Update < Excom::Command
+  class Update < Excom::Service
+    # `use` class method adds a plugin to a service with specified options
+    use :status, success: [:ok], failure: [:unprocessable_entity]
+    
     args :todo
     opts :params
 
-    def run
+    def execute!
       if todo.update(params)
-        result success: todo.as_json
+        ok todo.as_json
       else
-        result failure: todo.errors
+        unprocessable_entity todo.errors
       end
     end
   end
@@ -49,34 +58,30 @@ end
 # app/controllers/todos/controller
 class TodosController < ApplicationController
   def update
-    command = Todos::Update.new(todo, params: todo_params)
+    service = Todos::Update.(todo, params: todo_params)
 
-    if command.execute.success?
-      render json: todo.result
-    else
-      render json: todo.result, status: :unprocessable_entity
-    end
+    render json: todo.result, status: service.status
   end
 end
 ```
 
 However, even this basic example can be highly optimized by using Excom extensions and helper methods.
 
-### Command arguments and options
+### Service arguments and options
 
-Read full version on [wiki](https://github.com/akuzko/excom/wiki#instantiating-command-with-arguments-and-options).
+Read full version on [wiki](https://github.com/akuzko/excom/wiki#instantiating-service-with-arguments-and-options).
 
-Excom commands can be initialized with _arguments_ and _options_ (named arguments). To specify list
+Excom services can be initialized with _arguments_ and _options_ (named arguments). To specify list
 of available arguments and options, use `args` and `opts` class methods. All arguments and options
-are optional during command initialization. However, you cannot pass more arguments to command or
+are optional during service initialization. However, you cannot pass more arguments to service or
 options that were not declared with `opts` method.
 
 ```rb
-class MyCommand < Excom::Command
+class MyService < Excom::Service
   args :foo
   opts :bar
 
-  def run
+  def execute!
     # do something
   end
 
@@ -85,84 +90,91 @@ class MyCommand < Excom::Command
   end
 end
 
-c1 = MyCommand.new
-c1.foo # => 5
-c1.bar # => nil
+s1 = MyService.new
+s1.foo # => 5
+s1.bar # => nil
 
-c2 = c1.with_args(1).with_opts(bar: 2)
-c2.foo # => 1
-c2.bar # => 2
+s2 = s1.with_args(1).with_opts(bar: 2)
+s2.foo # => 1
+s2.bar # => 2
 ```
 
-### Command Execution
+### Service Execution
 
-Read full version on [wiki](https://github.com/akuzko/excom/wiki#command-execution).
+Read full version on [wiki](https://github.com/akuzko/excom/wiki#service-execution).
 
-At the core of each command's execution lies `run` method. You can use `status` and/or
-`result` methods to set execution status and result. If none were used, result and status
-will be set based on `run` method's return value.
+At the core of each service's execution lies `execute!` method. By default, you can use
+`success`, `failure` and `result` methods to set execution status and result. If none
+were used, result and status will be set based on `execute!` method's return value.
 
 Example:
 
 ```rb
-class MyCommand < Excom::Command
-  alias_success :ok
+class MyService < Excom::Service
   args :foo
 
-  def run
+  def execute!
     if foo > 2
-      result ok: foo * 2
+      success { foo * 2 }
     else
-      result failure: -1
+      failure { -1 }
     end
   end
 end
 
-command = MyCommand.new(3)
-command.execute.success? # => true
-command.status # => :ok
-command.result # => 6
+service = MyService.new(3)
+service.execute.success? # => true
+service.result # => 6
 ```
 
 ### Core API
 
 Please read about core API and available class and instance methods on [wiki](https://github.com/akuzko/excom/wiki#core-api)
 
-### Command Extensions (Plugins)
+### Service Extensions (Plugins)
 
 Read full version on [wiki](https://github.com/akuzko/excom/wiki/Plugins).
 
 Excom is built with extensions in mind. Even core functionality is organized in plugins that are
-used in base `Excom::Command` class. Bellow you can see a list of plugins with some description
+used in base `Excom::Service` class. Bellow you can see a list of plugins with some description
 and examples that are shipped with `excom`:
 
-- [`:status_helpers`](https://github.com/akuzko/excom/wiki/Plugins#status-helpers) - Allows you to
-define status aliases and helper methods named after them to immediately and more explicitly assign
-both status and result at the same time:
+- [`:status`](https://github.com/akuzko/excom/wiki/Plugins#status) - Adds `status` execution state
+property to the service, as well as helper methods and behavior to set it. `status` property is not
+bound to the "success" flag of execution state and can have any value depending on your needs. It
+is up to you to setup which statuses correspond to successful execution and which are not. Generated
+status helper methods allow to atomically and more explicitly assign both status and result at
+the same time:
 
 ```rb
-class Todos::Update
-  use :status_helpers, success: [:ok], failure: [:unprocessable_entity]
-  args :todo, :params
-
-  def run
-    if todo.update(params)
-      ok todo.as_json
+class Posts::Update < Excom::Service
+  use :status,
+    success: [:ok],
+    failure: [:unprocessable_entity]
+  
+  args :post, :params
+
+  def execute!
+    if post.update(params)
+      ok post.as_json
     else
-      unprocessable_entity todo.errors
+      unprocessable_entity post.errors
     end
   end
 end
 
-command = Todos::Update.(todo, todo_params)
+service = Posts::Update.(post, post_params)
 # in case params were valid you will have:
-command.success? # => true
-command.status # => :ok
-command.result # => {'id' => 1, ...}
+service.success? # => true
+service.status # => :ok
+service.result # => {'id' => 1, ...}
 ```
 
+Note that unlike `success`, `failure`, or `result` methods, status helpers accept result value
+as its argument rather than yield to a block to get it.
+
 - [`:context`](https://github.com/akuzko/excom/wiki/Plugins#context) - Allows you to set an execution
-context for a block that will be available to any command that uses this plugin via `context` method.
+context for a block that will be available to any service that uses this plugin via `context` method.
 
 ```rb
 # application_controller.rb
@@ -176,30 +188,30 @@ end
 ```
 
 ```rb
-class Posts::Archive < Excom::Command
+class Posts::Archive < Excom::Service
   use :context
   args :post
 
-  def run
+  def execute!
     post.update(archived: true, archived_by: context[:current_user])
   end
 end
 ```
 
 - [`:sentry`](https://github.com/akuzko/excom/wiki/Plugins#sentry) - Allows you to define sentry logic that
-will allow or deny command's execution or other related checks. This logic can be defined inline in command
+will allow or deny service's execution or other related checks. This logic can be defined inline in service
 classes or in dedicated Sentry classes. Much like [pundit](https://github.com/elabs/pundit) Policies, but
 more. Where pundit governs only authorization logic, Excom's Sentries can deny execution with any reason
 you find appropriate.
 
 ```rb
-class Posts::Destroy < Excom::Command
+class Posts::Destroy < Excom::Service
   use :context
   use :sentry
 
   args :post
 
-  def run
+  def execute!
     post.destroy
   end
 
@@ -222,16 +234,46 @@ end
 ```
 
 - [`:assertions`](https://github.com/akuzko/excom/wiki/Plugins#assertions) - Provides `assert` method that
-can be used for different logic checks during command execution.
+can be used for different logic checks during service execution.
+
+- [`:failure_cause`](https://github.com/akuzko/excom/wiki/Plugins#failure_cause) - A small helper plugin
+that can be used to more explicit access to cause of service failure. You can use it if you feel that
+failed service shouldn't have a result, but a cause of the failure instead. Example:
+
+```rb
+class Posts::Create < Excom::Service
+  use :status, success: [:ok], failure: [:unprocessable_entity]
+  use :failure_cause, cause_method_name: :errors
+  
+  args :params
+
+  def execute!
+    if post.save
+      ok post.as_json
+    else
+      unprocessable_entity post.errors
+    end
+  end
+
+  private def post
+    @post ||= Post.new(params)
+  end
+end
+
+service = Posts::Create.(title: 'invalid')
+service.success? # => false
+service.result # => nil
+service.errors # => {title: ["is invalid"]}
+```
 
 - [`:dry_types`](https://github.com/akuzko/excom/wiki/Plugins#dry-types) - Allows you to use
 [dry-types](http://dry-rb.org/gems/dry-types/) attributes instead of default `args` and `opts`.
 
 - [`:caching`](https://github.com/akuzko/excom/wiki/Plugins#caching) - Simple plugin that will prevent
-re-execution of command if it already has been executed, and will immediately return result.
+re-execution of service if it already has been executed, and will immediately return result.
 
 - [`:rescue`](https://github.com/akuzko/excom/wiki/Plugins#rescue) - Provides `:rescue` execution option.
-If set to `true`, any error occurred during command execution will not be raised outside.
+If set to `true`, any error occurred during service execution will not be raised outside.
 
 ## Development
 

data/bin/console

@@ -5,14 +5,14 @@ require "excom"
 
 Excom::Sentry.deny_with :unauthorized
 
-class Show < Excom::Command
+class Show < Excom::Service
   use :sentry, class: 'MySentry'
   use :caching
   use :dry_types
 
-  attribute :foo, Dry::Types['int']
+  attribute :foo, Dry::Types['integer']
 
-  def run
+  def execute!
     {foo: foo}
   end
 end
@@ -27,22 +27,29 @@ class MySentry < Excom::Sentry
   end
 end
 
-class Save < Excom::Command
+class MyErrors < Hash
+  def add(key, message)
+    (self[key] ||= []) << message
+  end
+end
+
+class Save < Excom::Service
+  use :status
   use :sentry, delegate: [:threshold]
   use :assertions
+  use :errors, errors_class: MyErrors
 
   args :foo
   opts :bar, :baz
 
-  alias_success :ok
-
   def foo
     super || 6
   end
 
-  def run
-    result ok: foo * 2
+  def execute!
+    result { foo * 2 }
     assert { foo > bar }
+    errors.add(:foo, 'invalid') if foo > 5
   end
 
   def threshold

data/excom.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Artem Kuzko"]
   spec.email         = ["a.kuzko@gmail.com"]
 
-  spec.summary       = %q{Flexible and highly extensible Commands (Service Objects) for business logic}
-  spec.description   = %q{Flexible and highly extensible Commands (Service Objects) for business logic}
+  spec.summary       = %q{Flexible and highly extensible Services for business logic organization}
+  spec.description   = %q{Flexible and highly extensible Services for business logic organization}
   spec.homepage      = "https://github.com/akuzko/excom"
   spec.license       = "MIT"
 
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "dry-types", "~> 0.12"
+  spec.add_development_dependency "dry-types", "~> 0.13.0"
   spec.add_development_dependency "dry-struct", "~> 0.4"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-its", "~> 1.2"

data/lib/excom.rb

@@ -2,7 +2,7 @@ require "excom/version"
 
 module Excom
   autoload :Plugins, 'excom/plugins'
-  autoload :Command, 'excom/command'
+  autoload :Service, 'excom/service'
 
   extend Plugins::Context::ExcomMethods
 

data/lib/excom/plugins.rb

@@ -10,12 +10,12 @@ module Excom
     def fetch(name)
       require("excom/plugins/#{name}") unless plugins.key?(name)
 
-      plugins[name] || fail("extension `#{name}` is not registered")
+      plugins[name] || raise("extension `#{name}` is not registered")
     end
 
     def register(name, extension, options = {})
       if plugins.key?(name)
-        fail ArgumentError, "extension `#{name}` is already registered"
+        raise ArgumentError, "extension `#{name}` is already registered"
       end
       extension.singleton_class.send(:define_method, :excom_options) { options }
       plugins[name] = extension

data/lib/excom/plugins/args.rb

@@ -10,6 +10,8 @@ module Excom
 
       @args = args
       @opts = opts
+
+      super()
     end
 
     def initialize_clone(*)
@@ -54,7 +56,7 @@ module Excom
       allowed = self.class.args_list.length
 
       if actual.length > allowed
-        fail ArgumentError, "wrong number of args (given #{actual.length}, expected 0..#{allowed})"
+        raise ArgumentError, "wrong number of args (given #{actual.length}, expected 0..#{allowed})"
       end
     end
 
@@ -62,16 +64,17 @@ module Excom
       unexpected = actual.keys - self.class.opts_list
 
       if unexpected.any?
-        fail ArgumentError, "wrong opts #{unexpected} given"
+        raise ArgumentError, "wrong opts #{unexpected} given"
       end
     end
 
     module ClassMethods
-      def inherited(command_class)
-        command_class.const_set(:ArgMethods, Module.new)
-        command_class.send(:include, command_class::ArgMethods)
-        command_class.args_list.replace args_list.dup
-        command_class.opts_list.replace opts_list.dup
+      def inherited(service_class)
+        service_class.const_set(:ArgMethods, Module.new)
+        service_class.send(:include, service_class::ArgMethods)
+        service_class.args_list.replace args_list.dup
+        service_class.opts_list.replace opts_list.dup
+        super
       end
 
       def arg_methods
@@ -83,6 +86,8 @@ module Excom
 
         argz.each_with_index do |name, i|
           arg_methods.send(:define_method, name){ @args[i] }
+
+          arg_methods.send(:define_method, "#{name}?"){ !!@args[i] }
         end
       end
 
@@ -91,6 +96,8 @@ module Excom
 
         optz.each do |name|
           arg_methods.send(:define_method, name){ @opts[name] }
+
+          arg_methods.send(:define_method, "#{name}?"){ !!@opts[name] }
         end
       end
 

data/lib/excom/plugins/assertions.rb

@@ -2,11 +2,11 @@ module Excom
   module Plugins::Assertions
     Plugins.register :assertions, self
 
-    def assert(fail_with: self.fail_with)
+    def assert
       if yield
-        status :success unless defined?(@status)
+        success! unless state.has_success?
       else
-        failure!(fail_with)
+        failure!
       end
     end
   end

data/lib/excom/plugins/caching.rb

@@ -1,11 +1,18 @@
 module Excom
   module Plugins::Caching
-    Plugins.register :caching, self, use_with: :prepend
+    Plugins.register :caching, self
 
-    def execute(*)
-      return super if block_given? || !executed?
+    def initialize(*)
+      super
+      extend Extension
+    end
+
+    module Extension
+      def execute(*)
+        return super if block_given? || !executed?
 
-      self
+        self
+      end
     end
   end
 end

data/lib/excom/plugins/context.rb

@@ -21,8 +21,10 @@ module Excom
       end
     end
 
-    def local_context
-      @local_context
+    def execute(*)
+      Excom.with_context(context) do
+        super
+      end
     end
 
     module ExcomMethods

data/lib/excom/plugins/dry_types.rb

@@ -5,11 +5,11 @@ module Excom
     attr_accessor :attributes
     protected :attributes=
 
-    def self.used(command_class, *)
+    def self.used(service_class, *)
       require 'dry-types'
       require 'dry-struct'
 
-      command_class.const_set(:Attributes, Class.new(Dry::Struct))
+      service_class.const_set(:Attributes, Class.new(Dry::Struct))
     end
 
     def initialize(attrs)
@@ -41,30 +41,26 @@ module Excom
     end
 
     def with_args(*)
-      fail "`with_args' method is not available with :dry_types plugin. use `with_attributes' method instead"
+      raise("`with_args' method is not available with :dry_types plugin. use `with_attributes' method instead")
     end
 
     def with_opts(*)
-      fail "`with_opts' method is not available with :dry_types plugin. use `with_attributes' method instead"
+      raise("`with_opts' method is not available with :dry_types plugin. use `with_attributes' method instead")
     end
 
     module ClassMethods
       def args(*)
-        fail "`args' method is not available with :dry_types plugin. use `attribute' method instead"
+        raise("`args' method is not available with :dry_types plugin. use `attribute' method instead")
       end
 
       def opts(*)
-        fail "`args' method is not available with :dry_types plugin. use `attribute' method instead"
+        raise("`args' method is not available with :dry_types plugin. use `attribute' method instead")
       end
 
       def attribute(name, *args)
         const_get(:Attributes).send(:attribute, name, *args)
         arg_methods.send(:define_method, name){ @attributes.send(name) }
       end
-
-      def constructor_type(*args)
-        const_get(:Attributes).send(:constructor_type, *args)
-      end
     end
   end
 end

data/lib/excom/plugins/errors.rb

@@ -0,0 +1,38 @@
+module Excom
+  module Plugins::Errors
+    Plugins.register :errors, self,
+      default_options: {errors_class: Hash, fail_if_present: true}
+
+    def self.used(service_class, *)
+      service_class.add_execution_prop(:errors)
+    end
+
+    def execute(*)
+      super
+
+      if self.class.plugins[:errors].options[:fail_if_present] && !errors.empty?
+        failure!
+      end
+
+      self
+    end
+
+    private def initialize(*)
+      super
+      state.errors = errors_class.new
+    end
+
+    def errors
+      state.errors
+    end
+
+    private def errors_class
+      self.class.plugins[:errors].options[:errors_class]
+    end
+
+    private def clear_execution_state!
+      super
+      state.errors = errors_class.new
+    end
+  end
+end

data/lib/excom/plugins/executable.rb

@@ -1,12 +1,59 @@
+require 'ostruct'
+
 module Excom
   module Plugins::Executable
     Plugins.register :executable, self
 
-    Result = Struct.new(:status, :result)
+    class State
+      def self.prop_names
+        @prop_names ||= []
+      end
+
+      def self.add_prop(*props)
+        prop_names.push(*props)
+        props.each{ |prop| def_prop_accessor(prop) }
+      end
+
+      def self.def_prop_accessor(name)
+        define_method(name) { @values[name] }
+        define_method("#{name}=") { |value| @values[name] = value }
+        define_method("has_#{name}?") { @values.key?(name) }
+      end
+
+      def initialize(values = {})
+        @values = values
+      end
+
+      def clear!
+        @values.clear
+      end
+
+      def prop_names
+        self.class.prop_names
+      end
+
+      def replace(other)
+        missing_props = prop_names - other.prop_names
+
+        unless missing_props.empty?
+          raise ArgumentError, "cannot accept execution state #{other} due to missing props: #{missing_props}"
+        end
+
+        prop_names.each do |prop|
+          @values[prop] = other.public_send(prop)
+        end
+      end
+    end
+
+    def self.used(service_class, *)
+      service_class.const_set(:State, Class.new(State))
+      service_class.add_execution_prop(:executed, :success, :result)
+    end
+
+    attr_reader :state
 
     def initialize(*)
-      @executed = false
-      super
+      @state = self.class::State.new(executed: false)
     end
 
     def initialize_clone(*)
@@ -15,108 +62,114 @@ module Excom
 
     def execute(*, &block)
       clear_execution_state!
-      result = run(&block)
-      result_with(result) unless defined? @result
-      @executed = true
+      result = execute!(&block)
+      result_with(result) unless state.has_result?
+      state.executed = true
 
       self
     end
 
     def executed?
-      @executed
+      state.executed
     end
 
     def ~@
-      Result.new(status, result)
+      state
     end
 
-    private def run
+    private def execute!
       success!
     end
 
     private def clear_execution_state!
-      @executed = false
-      remove_instance_variable('@result'.freeze) if defined?(@result)
-      remove_instance_variable('@status'.freeze) if defined?(@status)
+      state.clear!
+      state.executed = false
     end
 
-    def result(obj = UNDEFINED)
-      return @result if obj == UNDEFINED
+    private def success
+      assign_successful_state
+      assign_successful_result(yield)
+    end
 
-      case obj
-      when Hash
-        if obj.length != 1
-          fail ArgumentError, "expected 1-item status-result pair, got: #{obj.inspect}"
-        end
+    private def failure
+      assign_failed_state
+      assign_failed_result(yield)
+    end
 
-        @status, @result = obj.first
-      else
-        result_with(obj)
-      end
+    private def success!
+      assign_successful_state
     end
 
-    private def result_with(obj)
-      if Result === obj
-        @status, @result = obj.status, obj.result
-        return @result
-      end
+    private def failure!
+      assign_failed_state
+    end
 
-      @status = obj ? :success : fail_with unless defined?(@status)
-      @result = obj
+    private def assign_successful_state
+      state.success = true
+      state.result = nil
     end
 
-    def status(status = UNDEFINED)
-      return @status = status unless status == UNDEFINED
+    private def assign_failed_state
+      state.success = false
+      state.result = nil
+    end
 
-      @status
+    private def assign_successful_result(value)
+      state.result = value
     end
 
-    def success?
-      status == :success || self.class.success_aliases.include?(status)
+    private def assign_failed_result(value)
+      state.result = value
     end
 
-    def failure?
-      !success?
+    def result
+      return state.result unless block_given?
+
+      result_with(yield)
     end
 
-    private def success!
-      @status = :success
-      @result = true
+    private def result_with(obj)
+      if State === obj
+        return state.replace(obj)
+      end
+
+      state.success = !!obj
+      if state.success
+        assign_successful_result(obj)
+      else
+        assign_failed_result(obj)
+      end
     end
 
-    private def failure!(status = fail_with)
-      @status = status
+    def success?
+      state.success == true
     end
 
-    protected def fail_with
-      self.class.fail_with
+    def failure?
+      !success?
     end
 
     module ClassMethods
-      def call(*args)
-        new(*args).execute
-      end
-
-      def [](*args)
-        call(*args).result
+      def inherited(klass)
+        klass.const_set(:State, Class.new(self::State))
+        klass::State.prop_names.replace(self::State.prop_names.dup)
       end
 
-      def fail_with(status = nil)
-        return @fail_with || :failure if status.nil?
-
-        @fail_with = status
+      def add_execution_prop(*props)
+        self::State.add_prop(*props)
       end
 
-      def success_aliases
-        []
+      def call(*args)
+        new(*args).execute
       end
+      alias_method :execute, :call
 
-      def alias_success(*aliases)
-        singleton_class.send(:define_method, :success_aliases) { super() + aliases }
+      def [](*args)
+        call(*args).result
       end
 
       def method_added(name)
-        private :run if name == :run
+        private :execute! if name == :execute!
         super if defined? super
       end
     end

data/lib/excom/plugins/failure_cause.rb

@@ -0,0 +1,16 @@
+module Excom
+  module Plugins::FailureCause
+    Plugins.register :failure_cause, self,
+      default_options: {cause_method_name: :cause}
+
+    def self.used(service_class, cause_method_name:)
+      service_class.add_execution_prop(:cause)
+      service_class.send(:define_method, cause_method_name) { state.cause }
+    end
+
+    private def assign_failed_result(value)
+      state.result = nil
+      state.cause = value
+    end
+  end
+end

data/lib/excom/plugins/pluggable.rb

@@ -6,6 +6,9 @@ module Excom
       method = extension.excom_options[:use_with] || :include
       send(method, extension)
 
+      defaults = extension.excom_options[:default_options]
+      opts = defaults.merge(opts) unless defaults.nil?
+
       if extension.const_defined?('ClassMethods')
         extend extension::ClassMethods
       end
@@ -19,10 +22,14 @@ module Excom
       extension
     end
 
+    def using?(name)
+      plugins.key?(name)
+    end
+
     def plugins
       @plugins ||= {}
     end
-    alias :extensions :plugins
+    alias extensions plugins
 
     Reflection = Struct.new(:extension, :options)
   end

data/lib/excom/plugins/rescue.rb

@@ -2,11 +2,9 @@ module Excom
   module Plugins::Rescue
     Plugins.register :rescue, self
 
-    attr_reader :error
-
-    def initialize_clone(*)
-      remove_instance_variable('@error') if defined?(@error)
-      super
+    def self.used(service_class, *)
+      service_class.use(:status) unless service_class.using?(:status)
+      service_class.add_execution_prop :error
     end
 
     def execute(**opts)
@@ -14,12 +12,16 @@ module Excom
       super
     rescue StandardError => error
       clear_execution_state!
-      @error = error
-      @status = :error
+      failure!(:error)
+      state.error = error
       raise error unless rezcue
       self
     end
 
+    def error
+      state.error
+    end
+
     def error?
       status == :error
     end

data/lib/excom/plugins/sentry.rb

@@ -4,14 +4,15 @@ module Excom
 
     Plugins.register :sentry, self
 
-    def self.used(command_class, **opts)
+    def self.used(service_class, **opts)
       klass = opts[:class]
 
-      command_class._sentry_class = klass if klass
+      service_class.use(:status) unless service_class.using?(:status)
+      service_class._sentry_class = klass if klass
     end
 
     def execute(*)
-      reason = why_cant(:execute)
+      reason = why_cant?(:execute)
 
       return super if reason.nil?
 
@@ -21,10 +22,10 @@ module Excom
     end
 
     def can?(action)
-      why_cant(action).nil?
+      why_cant?(action).nil?
     end
 
-    def why_cant(action)
+    def why_cant?(action)
       sentry.denial_reason(action)
     end
 
@@ -39,9 +40,9 @@ module Excom
     module ClassMethods
       attr_writer :_sentry_class
 
-      def inherited(command_class)
+      def inherited(service_class)
         super
-        command_class.sentry_class(_sentry_class)
+        service_class.sentry_class(_sentry_class)
       end
 
       def sentry_class(klass = UNDEFINED)
@@ -59,7 +60,7 @@ module Excom
             _sentry_class
           end
 
-        @sentry_class.command_class = self
+        @sentry_class.service_class = self
         @sentry_class
       end
 
@@ -74,7 +75,7 @@ module Excom
           const_get(:Sentry).class_eval(&block)
         else
           @_sentry_class = @sentry_class = Class.new(Sentry, &block)
-          @sentry_class.command_class = self
+          @sentry_class.service_class = self
           const_set(:Sentry, @_sentry_class)
         end
       end

data/lib/excom/plugins/sentry/sentinel.rb

@@ -9,13 +9,13 @@ module Excom
         sentry_class.send(:include, sentry_class::Delegations)
       end
 
-      def self.command_class=(klass)
-        sentinels.each{ |s| s.command_class = klass }
-        @command_class = klass
+      def self.service_class=(klass)
+        sentinels.each{ |s| s.service_class = klass }
+        @service_class = klass
       end
 
-      def self.command_class
-        @command_class
+      def self.service_class
+        @service_class
       end
 
       def self.deny_with(reason)
@@ -56,10 +56,10 @@ module Excom
         const_get(:Delegations)
       end
 
-      attr_reader :command
+      attr_reader :service
 
-      def initialize(command)
-        @command = command
+      def initialize(service)
+        @service = service
       end
 
       def denial_reason(action)
@@ -74,7 +74,7 @@ module Excom
 
       def sentry(klass)
         klass = derive_sentry_class(klass) unless Class === klass
-        klass.new(command)
+        klass.new(service)
       end
 
       def to_hash
@@ -93,7 +93,7 @@ module Excom
 
       private def sentinels
         @sentinels ||= self.class.sentinels.map do |klass|
-          klass.new(command)
+          klass.new(service)
         end
       end
 
@@ -104,7 +104,7 @@ module Excom
       end
 
       private def constantize(klass, sentry_name)
-        module_prefix = (inline? ? self.class.command_class.name : self.class.name).sub(/[^:]+\Z/, ''.freeze)
+        module_prefix = (inline? ? self.class.service_class.name : self.class.name).sub(/[^:]+\Z/, ''.freeze)
 
         klass_name = module_prefix + "_#{klass}".gsub!(/(_([a-z]))/){ $2.upcase } + sentry_name
 
@@ -114,15 +114,15 @@ module Excom
       end
 
       private def inline?
-        self.class.command_class.const_defined?(:Sentry) && self.class.command_class::Sentry == self.class
+        self.class.service_class.const_defined?(:Sentry) && self.class.service_class::Sentry == self.class
       end
 
       private def define_delegations!
-        delegated_methods = self.class.command_class.arg_methods.instance_methods +
-          Array(self.class.command_class.plugins[:sentry].options[:delegate])
+        delegated_methods = self.class.service_class.arg_methods.instance_methods +
+          Array(self.class.service_class.plugins[:sentry].options[:delegate])
 
         delegated_methods.each do |name|
-          self.class.delegations.send(:define_method, name) { command.public_send(name) }
+          self.class.delegations.send(:define_method, name) { service.public_send(name) }
         end
 
         self.class.instance_variable_set('@delegations_defined'.freeze, true)

data/lib/excom/plugins/status.rb

@@ -0,0 +1,57 @@
+module Excom
+  module Plugins::Status
+    Plugins.register :status, self,
+      default_options: {success: [], failure: []}
+
+    def self.used(service_class, success:, failure:)
+      service_class.add_execution_prop(:status)
+
+      helpers = Module.new do
+        success.each do |name|
+          define_method(name) do |result = nil|
+            success(name) { result }
+          end
+        end
+
+        failure.each do |name|
+          define_method(name) do |result = nil|
+            failure(name) { result }
+          end
+        end
+      end
+
+      service_class.const_set('StatusHelpers', helpers)
+      service_class.send(:include, helpers)
+    end
+
+    def status
+      state.status
+    end
+
+    private def success!(status = :success)
+      state.status = status 
+      super()
+    end
+
+    private def success(status = :success, &block)
+      state.status = status
+      super(&block)
+    end
+
+    private def failure!(status = :failure)
+      state.status = status
+      super()
+    end
+
+    private def failure(status = :failure, &block)
+      super(&block).tap do
+        state.status = status
+      end
+    end
+
+    private def result_with(*)
+      super
+      state.status ||= state.success ? :success : :failure
+    end
+  end
+end

data/lib/excom/{command.rb → service.rb}

@@ -1,5 +1,5 @@
 module Excom
-  class Command
+  class Service
     extend Excom::Plugins::Pluggable
 
     use :executable

data/lib/excom/version.rb

@@ -1,3 +1,3 @@
 module Excom
-  VERSION = "0.4.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excom
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Artem Kuzko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-11 00:00:00.000000000 Z
+date: 2019-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: 0.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: dry-struct
   requirement: !ruby/object:Gem::Requirement
@@ -122,8 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Flexible and highly extensible Commands (Service Objects) for business
-  logic
+description: Flexible and highly extensible Services for business logic organization
 email:
 - a.kuzko@gmail.com
 executables: []
@@ -141,19 +140,21 @@ files:
 - bin/setup
 - excom.gemspec
 - lib/excom.rb
-- lib/excom/command.rb
 - lib/excom/plugins.rb
 - lib/excom/plugins/args.rb
 - lib/excom/plugins/assertions.rb
 - lib/excom/plugins/caching.rb
 - lib/excom/plugins/context.rb
 - lib/excom/plugins/dry_types.rb
+- lib/excom/plugins/errors.rb
 - lib/excom/plugins/executable.rb
+- lib/excom/plugins/failure_cause.rb
 - lib/excom/plugins/pluggable.rb
 - lib/excom/plugins/rescue.rb
 - lib/excom/plugins/sentry.rb
 - lib/excom/plugins/sentry/sentinel.rb
-- lib/excom/plugins/status_helpers.rb
+- lib/excom/plugins/status.rb
+- lib/excom/service.rb
 - lib/excom/version.rb
 homepage: https://github.com/akuzko/excom
 licenses:
@@ -178,5 +179,5 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: Flexible and highly extensible Commands (Service Objects) for business logic
+summary: Flexible and highly extensible Services for business logic organization
 test_files: []

data/lib/excom/plugins/status_helpers.rb

@@ -1,25 +0,0 @@
-module Excom
-  module Plugins::StatusHelpers
-    Plugins.register :status_helpers, self
-
-    def self.used(klass, success: [], failure: [])
-      klass.alias_success(*success)
-
-      helpers = Module.new do
-        (success + failure).each do |name|
-          define_method(name) do |result = nil|
-            @status = name
-            @result = result
-          end
-        end
-      end
-
-      klass.const_set('StatusHelpers', helpers)
-      klass.send(:include, helpers)
-    end
-
-    def success?
-      super || self.class.success_aliases.include?(status)
-    end
-  end
-end