Module: Cuprum::Processing

Parent Namespace

Cuprum

Included Modules

Cuprum::ResultHelpers

Defined In

lib/cuprum/processing.rb

Table Of Contents

• Overview
  • Examples
  • See Also
• Instance Methods
  • arity
  • call
  • process

Overview

Functional implementation for creating a command object. Cuprum::Processing defines a #call method, which performs the implementation defined by #process and returns an instance of Cuprum::Result.

Examples

Defining a command with Cuprum::Processing.

class AdderCommand
  include Cuprum::Processing

  def initialize addend
    @addend = addend
  end

  private

  def process int
    int + addend
  end
end

adder  = AdderCommand.new(2)
result = adder.call(3)
#=> an instance of Cuprum::Result
result.value    #=> 5
result.success? #=> true

Defining a command with error handling.

class SquareRootCommand
  include Cuprum::Processing

  private

  def process value
    if value.negative?
      return Cuprum::Result.new(error: 'value cannot be negative')
    end

    Math.sqrt(value)
  end
end

result = SquareRootCommand.new.call(2)
result.value    #=> 1.414
result.success? #=> true
result.failure? #=> false
result.error    #=> nil

result = SquareRootCommand.new.call(-1)
result.value    #=> nil
result.success? #=> false
result.failure? #=> true
result.error    #=> 'value cannot be negative'

See Also

• Cuprum::Command

Back To Top

Instance Methods

#arity => Integer

Returns an indication of the number of arguments accepted by #call.

If the method takes a fixed number N of arguments, returns N. If the method takes a variable number of arguments, returns -N-1, where N is the number of required arguments. Keyword arguments will be considered as a single additional argument, that argument being mandatory if any keyword argument is mandatory.

Returns

• (Integer) — The number of arguments.

See Also

• Method#arity

#call(*arguments, **keywords, &block) => Cuprum::Result

Executes the command and returns a Cuprum::Result or compatible object.

Each time #call is invoked, the object performs the following steps:

1. The #process method is called, passing the arguments, keywords, and block that were passed to #call.
2. If the value returned by #process is a Cuprum::Result or compatible object, that result is directly returned by #call.
3. Otherwise, the value returned by #process will be wrapped in a successful result, which will be returned by #call.

Parameters

• arguments (Array) — Arguments to be passed to the implementation.
• keywords (Hash) — Keywords to be passed to the implementation.

Yields

• If a block argument is given, it will be passed to the implementation.

Returns

• (Cuprum::Result) — The result object for the command.

#process(*arguments, **keywords, &block) => Cuprum::Result, Object

Note: This is a private method.

The implementation of the command.

Whereas the #call method provides the public interface for calling a command, the #process method defines the actual implementation. This method should not be called directly.

When the command is called via #call, the parameters are passed to #process. If #process returns a result, that result will be returned by #call; otherwise, the value returned by #process will be wrapped in a successful Cuprum::Result object.

Parameters

• arguments (Array) — The arguments, if any, passed from #call.
• keywords (Hash) — The keywords, if any, passed from #call.

Yields

• The block, if any, passed from #call.

Returns

• (Cuprum::Result, Object) — a result object, or the value of the result object to be returned by #call.

Back To Top

---

Back to Documentation | Versions | 1.3 | Reference | Cuprum