fluxo 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383f612dadbf2c9b9c7cd5d8e4e09e3f140a8665405e3069e29e1c6629ff1da1
-  data.tar.gz: d91c37a9e158ad85b039cd3fb82d09881ed8390083e60ace2f3c345549902cff
+  metadata.gz: 9411907ecd9869558ef765adeb057b14d382d0da5576e5461d7ded3f27dc151e
+  data.tar.gz: 8815e173af9d860f67296aea9db1880202c0c30a56b8b00e65ce820de4bad6e7
 SHA512:
-  metadata.gz: b7ba58999435d17f261decb8bd64a37f2f75135027a3e3683cce67ceae08bd065145c31e0c5e9f70c394fa944faa2e20986cf15860ca90236c0feb06d54a68ab
-  data.tar.gz: 8d2b54df3b612c2c6f20430d9086ff2a53a958ae9989a8605c05bfe12ebf2e3c93978b1add2af3919f5a6a99c294ebe5b610ab9b10f34f21ba7979bdb5e30406
+  metadata.gz: e67f568a96a0afef091d6865276f07b9be67cfac978795d53520b3c103e7b9dadfe552f019b470c9333c201ab1241707aacc5adcf1b18024a275b50a87368c7d
+  data.tar.gz: c599c6723cba2de6c27699a2708299424b951c1a12204f2cb285f71b245d4afb0be2fa0dfbdb02212e8925fb2497769922d7056861da0ba7c37e8ab848db6645

data/.tool-versions

@@ -1 +1 @@
-ruby 2.7.2
+ruby 2.7.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fluxo (0.2.1)
+    fluxo (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -30,27 +30,16 @@ end
 ```
 
 And then just use the opperation by calling:
-```
+```ruby
 result = MyOperation.call
 result.success? # => true
 result.value # => :ok
 ```
 
-In order to execute an operation with parameters, you must first define list of attributes:
+In order to execute an operation with parameters, you just need to pass them to the call method:
 
 ```ruby
 class MyOperation < Fluxo::Operation
-  attributes :param1, :param2
-
-  def call!(param1:, param2:)
-    Success(:ok)
-  end
-end
-```
-
-or use the shortcut for defining attributes:
-```ruby
-class MyOperation < Fluxo::Operation(:param1, :param2)
   def call!(param1:, param2:)
     Success(:ok)
   end
@@ -67,7 +56,9 @@ The execution result of an operation is a `Fluxo::Result` object. There are thre
 Use the `Success` and `Failure` methods to create results accordingly.
 
 ```ruby
-class AgeCheckOperation < Fluxo::Operation(:age)
+class AgeCheckOperation < Fluxo::Operation
+  self.strict = false # By default, operations are strict. You must it to catch errors and use on_error hook.
+
   def call!(age:)
     age >= 18 ? Success('ok') : Failure('too young')
   end
@@ -97,7 +88,7 @@ AgeCheckOperation.call(age: 18)
 You can also define multiple callbacks for the opportunity result. The callbacks are executed in the order they were defined. You can filter which callbacks are executed by specifying an identifier to the `Success(id) { }` or `Failure(id) { }` methods along with its value as a block.
 
 ```ruby
-class AgeCategoriesOperation < Fluxo::Operation(:age)
+class AgeCategoriesOperation < Fluxo::Operation
   def call!(age:)
     case age
     when 0..14
@@ -128,7 +119,7 @@ AgeCategoriesOperation.call(age: 18) \
 Once things become more complex, you can use can define a `flow` with a list of steps to be executed:
 
 ```ruby
-class ArithmeticOperation < Fluxo::Operation(:num)
+class ArithmeticOperation < Fluxo::Operation
   flow :normalize, :plus_one, :double, :square, :wrap
 
   def normalize(num:)
@@ -159,12 +150,10 @@ ArithmeticOperation.call(num: 1) \
 # Result: 16
 ```
 
-Notice that the value of each step is passed to the next step as an argument. And the last step is always the result of the operation.
-
-By default you can only pass defined attributes to the steps. You may want to pass transient attributes to the steps. You can do this by specifying a `transient_attributes` option to the operation class:
+Notice that the value of each step is passed to the next step as an argument. You can include more transient attributes during the flow execution. Step result with object different of a Hash will be ignored. And the last step is always the result of the operation.
 
 ```ruby
-class CreateUserOperation < Fluxo::Operation(:name, :age)
+class CreateUserOperation < Fluxo::Operation
   flow :build, :save
 
   def build(name:, age:)
@@ -180,32 +169,12 @@ class CreateUserOperation < Fluxo::Operation(:name, :age)
 end
 ```
 
-This is useful to make the flow data transparent to the operation. But you can also disable this by setting the `strict_transient_attributes` option to `false` under the Operation class or the global configuration.
-
-```ruby
-class CreateUserOperation < Fluxo::Operation(:name, :age)
-  self.strict_transient_attributes = false
-  # ...
-end
-# or globally
-Fluxo.config do |config|
-  config.strict_attributes = false
-  config.strict_transient_attributes = false
-end
-# or even
-Fluxo.config.strict_transient_attributes = false
-```
-
 ### Operation Groups
 
 Another very useful feature of Fluxo is the ability to group operations steps. Imagine that you want to execute a bunch of operations in a single transaction. You can do this by defining a the group method and specifying the steps to be executed in the group.
 
 ```ruby
-class CreateUserOperation < Fluxo::Operation(:name, :email)
-  transient_attributes :user, :profile
-
-  flow :build, {transaction: %i[save_user save_profile]}, :enqueue_job
-
+class ApplicationOperation < Fluxo::Operation
   private
 
   def transaction(**kwargs, &block)
@@ -215,6 +184,10 @@ class CreateUserOperation < Fluxo::Operation(:name, :email)
     end
     result
   end
+end
+
+class CreateUserOperation < ApplicationOperation
+  flow :build, {transaction: %i[save_user save_profile]}, :enqueue_job
 
   def build(name:, email:)
     user = User.new(name: name, email: email)
@@ -245,7 +218,7 @@ end
 If you have the `ActiveModel` gem installed, you can use the `validations` method to define validations on the operation.
 
 ```ruby
-class SubscribeOperation < Fluxo::Operation(:name, :email)
+class SubscribeOperation < Fluxo::Operation
   validations do
     validates :name, presence: true
     validates :email, presence: true, format: { with: /\A[^@]+@[^@]+\z/ }
@@ -262,19 +235,19 @@ end
 To promote single responsibility principle, Fluxo allows compose a complex operation flow by combining other operations.
 
 ```ruby
-class DoubleOperation < Fluxo::Operation(:num)
+class DoubleOperation < Fluxo::Operation
   def call!(num:)
     Success(num: num * 2)
   end
 end
 
-class SquareOperation < Fluxo::Operation(:num)
+class SquareOperation < Fluxo::Operation
   def call!(num:)
     Success(num: num * 2)
   end
 end
 
-class ArithmeticOperation < Fluxo::Operation(:num)
+class ArithmeticOperation < Fluxo::Operation
   flow :normalize, :double, :square
 
   def normalize(num:)
@@ -294,11 +267,10 @@ end
 ### Configuration
 
 ```ruby
-Fluxo.config do |config|
+Fluxo.configure do |config|
   config.wrap_falsey_result = false
   config.wrap_truthy_result = false
-  config.strict_attributes = true
-  config.strict_transient_attributes = true
+  config.strict = true
   config.error_handlers << ->(result) { Honeybadger.notify(result.value) }
 end
 ```

data/ci/Gemfile.activemodel-4.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fluxo (0.2.1)
+    fluxo (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/ci/Gemfile.activemodel-5.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fluxo (0.2.1)
+    fluxo (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/ci/Gemfile.activemodel-6.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fluxo (0.2.1)
+    fluxo (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/ci/Gemfile.activemodel-7.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fluxo (0.2.1)
+    fluxo (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/fluxo/active_model_extension.rb

@@ -1,3 +1,4 @@
+require 'ostruct'
 
 module Fluxo
   module ActiveModelExtension
@@ -20,7 +21,7 @@ module Fluxo
       private
 
       def build_validations_proxy!
-        validator = Class.new do
+        validator = Class.new(OpenStruct) do
           include ActiveModel::Validations
 
           def self.validate!(operation_instance, **attrs)
@@ -44,10 +45,12 @@ module Fluxo
         end
 
         validator.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          attr_accessor #{attribute_names.map(&:inspect).join(", ")}
+          def self.name
+            "#{name || 'Fluxo::Operation'}::Validations"
+          end
 
-          def self.model_name
-            ::ActiveModel::Name.new(self, nil, %|#{name || "Anonymous"}|)
+          def self.to_s
+            name
           end
         RUBY
 

data/lib/fluxo/config.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 module Fluxo
-  def self.config
-    @config ||= Config.new
-    yield(@config) if block_given?
-    @config
+  class << self
+    def config
+      @config ||= Config.new
+      yield(@config) if block_given?
+      @config
+    end
+    alias_method :configure, :config
   end
 
   class Config
@@ -16,18 +19,18 @@ module Fluxo
     # When set to true, the result of a truthy operation will be wrapped in a Success.
     attr_accessor :wrap_truthy_result
 
-    # When set to true, the operation will not validate the transient_attributes defition during the flow step execution.
-    attr_accessor :strict_transient_attributes
-
-    # When set to true, the operation will not validate attributes definition before calling the operation.
-    attr_accessor :strict_attributes
+    # Auto handle errors/exceptions.
+    attr_writer :strict
 
     def initialize
       @error_handlers = []
       @wrap_falsey_result = false
       @wrap_truthy_result = false
-      @strict_transient_attributes = true
-      @strict_attributes = true
+      @strict = false
+    end
+
+    def strict?
+      !!@strict
     end
   end
 end

data/lib/fluxo/errors.rb

@@ -1,17 +1,20 @@
 module Fluxo
-  class Error < StandardError
-  end
+  module Errors
+    # @param result [Fluxo::Result] The result to be checked
+    def self.raise_operation_error!(result)
+      raise result if result.is_a?(Exception)
+      raise result.value if result.operation.class.strict?
 
-  class InvalidResultError < Error
+      [SyntaxError, ArgumentError, NoMethodError, Fluxo::Error].each do |exception|
+        raise result.value if result.value.is_a?(exception)
+      end
+    end
   end
 
-  class AttributeError < Error
-  end
-
-  class NotDefinedAttributeError < AttributeError
+  class Error < StandardError
   end
 
-  class MissingAttributeError < AttributeError
+  class InvalidResultError < Error
   end
 
   class ValidationDefinitionError < Error

data/lib/fluxo/operation/attributes.rb

@@ -8,60 +8,35 @@ module Fluxo
       end
 
       module ClassMethods
+        # This variable is used only when ActiveModel is available.
         attr_reader :validations_proxy
 
-        # When set to true, the operation will not validate the transient_attributes defition during the flow step execution.
-        attr_writer :strict_transient_attributes
+        # Auto handle errors/exceptions.
+        attr_writer :strict
 
-        # When set to true, the operation will not validate attributes definition before calling the operation.
-        attr_writer :strict_attributes
+        def strict?
+          return @strict if defined? @strict
 
-        def strict_attributes?
-          return @strict_attributes if defined?(@strict_attributes)
-
-          Fluxo.config.strict_attributes
-        end
-
-        def strict_transient_attributes?
-          return @strict_transient_attributes if defined?(@strict_transient_attributes)
-
-          Fluxo.config.strict_transient_attributes
+          @strict = Fluxo.config.strict?
         end
 
         def validations
           raise NotImplementedError, "ActiveModel is not defined to use validations."
         end
 
-        def attribute_names
-          @attribute_names ||= []
-        end
-
-        def transient_attribute_names
-          @transient_attribute_names ||= []
+        def required_attributes
+          @required_attributes ||= []
         end
 
-        def attributes(*names)
-          @attribute_names ||= []
-          names = names.map(&:to_sym) - @attribute_names
-          @attribute_names.push(*names)
+        def validate_attributes(*attributes)
+          @required_attributes ||= []
+          @required_attributes |= attributes
         end
+        alias_method :require_attribute, :validate_attributes
+        alias_method :attributes, :validate_attributes
 
-        def transient_attributes(*names)
-          @transient_attribute_names ||= []
-          names = names.map(&:to_sym) - @transient_attribute_names
-          @transient_attribute_names.push(*names)
-        end
-
-        def attribute?(key)
-          return false unless key
-
-          attribute_names.include?(key.to_sym)
-        end
-
-        def transient_attribute?(key)
-          return false unless key
-
-          transient_attribute_names.include?(key.to_sym)
+        def transient_attributes(*)
+          puts "DEPRECATED: #{__method__} is deprecated. Operation runs on sloppy mode by allowing any transient attribute."
         end
       end
     end

data/lib/fluxo/operation.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "operation/constructor"
 require_relative "operation/attributes"
 
 module Fluxo
@@ -8,9 +7,6 @@ module Fluxo
   # conflict with the Operation step methods that are going to inherit this class.
   class Operation
     include Attributes
-    include Constructor
-
-    def_Operation(::Fluxo)
 
     class << self
       def flow(*methods)
@@ -22,12 +18,11 @@ module Fluxo
 
         begin
           instance.__execute_flow__(steps: [:call!], attributes: attrs)
-        rescue InvalidResultError, AttributeError, ValidationDefinitionError => e
-          raise e
         rescue => e
-          Fluxo::Result.new(type: :exception, value: e, operation: instance, ids: %i[error]).tap do |result|
-            Fluxo.config.error_handlers.each { |handler| handler.call(result) }
-          end
+          result = Fluxo::Result.new(type: :exception, value: e, operation: instance, ids: %i[error])
+          Fluxo.config.error_handlers.each { |handler| handler.call(result) }
+          Fluxo::Errors.raise_operation_error!(result)
+          result
         end
       end
     end
@@ -41,19 +36,21 @@ module Fluxo
 
     # Calls step-method by step-method always passing the value to the next step
     # If one of the methods is a failure stop the execution and return a result.
-    def __execute_flow__(steps: [], attributes: {})
+    def __execute_flow__(steps: [], attributes: {}, validate: true)
       transient_attributes, transient_ids = attributes.dup, Hash.new { |h, k| h[k] = [] }
-      __validate_attributes__(first_step: steps.first, attributes: transient_attributes)
 
       result = nil
-      steps.unshift(:__validate__) if self.class.validations_proxy # add validate step before the first step
+      steps.unshift(:__validate_required_attributes__) if self.class.required_attributes.any? && validate
+      steps.unshift(:__validate__) if self.class.validations_proxy && validate
       steps.each_with_index do |step, idx|
         if step.is_a?(Hash)
-          step.each do |group_method, group_steps|
+          group_result = step.each do |group_method, group_steps|
             send(group_method, **transient_attributes) do |group_attrs|
-              result = __execute_flow__(steps: group_steps, attributes: (group_attrs || transient_attributes))
+              result = __execute_flow__(validate: false, steps: group_steps, attributes: (group_attrs || transient_attributes))
             end
+            result = group_result if group_result.is_a?(Fluxo::Result)
             break unless result.success?
+            transient_attributes = result.transient_attributes # Update transient attributes with the group result in case of value is not a Hash
           end
         else
           result = __wrap_result__(send(step, **transient_attributes))
@@ -69,6 +66,7 @@ module Fluxo
             next_step: steps[idx + 1]
           )
         end
+        result.mutate(transient_attributes: transient_attributes)
       end
       result.mutate(ids: transient_ids[result.type].uniq, operation: self)
     end
@@ -103,28 +101,6 @@ module Fluxo
 
     private
 
-    # Validates the operation was called with all the required keyword arguments.
-    # @param first_step [Symbol, Hash] The first step method
-    # @param attributes [Hash] The attributes to validate
-    # @return [void]
-    # @raise [MissingAttributeError] When a required attribute is missing
-    def __validate_attributes__(attributes:, first_step:)
-      if self.class.strict_attributes? && (extra = attributes.keys - self.class.attribute_names).any?
-        raise NotDefinedAttributeError, <<~ERROR
-          The following attributes are not defined: #{extra.join(", ")}
-
-          You can use the #{self.class.name}.attributes method to specify list of allowed attributes.
-          Or you can disable strict attributes mode by setting the strict_attributes to true.
-        ERROR
-      end
-
-      __expand_step_method__(first_step).each do |step|
-        method(step).parameters.select { |type, _| type == :keyreq }.each do |(_type, name)|
-          raise(MissingAttributeError, "Missing :#{name} attribute on #{self.class.name}#{step} step method.") unless attributes.key?(name)
-        end
-      end
-    end
-
     # Merge the result attributes with the new attributes. Also checks if the upcomming step
     # has the required attributes and transient attributes to a valid execution.
     # @param new_attributes [Hash] The new attributes
@@ -133,37 +109,7 @@ module Fluxo
     def __merge_result_attributes__(new_attributes:, old_attributes:, next_step:)
       return old_attributes unless new_attributes.is_a?(Hash)
 
-      attributes = old_attributes.merge(new_attributes)
-      allowed_attrs = self.class.attribute_names + self.class.transient_attribute_names
-      if self.class.strict_transient_attributes? &&
-          (extra = attributes.keys - allowed_attrs).any?
-        raise NotDefinedAttributeError, <<~ERROR
-          The following transient attributes are not defined: #{extra.join(", ")}
-
-          You can use the #{self.class.name}.transient_attributes method to specify list of allowed attributes.
-          Or you can disable strict transient attributes mode by setting the strict_transient_attributes to true.
-        ERROR
-      end
-
-      __expand_step_method__(next_step).each do |step|
-        method(step).parameters.select { |type, _| type == :keyreq }.each do |(_type, name)|
-          raise(MissingAttributeError, "Missing :#{name} transient attribute on #{self.class.name}##{step} step method.") unless attributes.key?(name)
-        end
-      end
-
-      attributes
-    end
-
-    # Return the step method as an array. When it's a hash it suppose to be a
-    # be a step group. In this case return its first key and its first value as
-    # the array of step methods.
-    #
-    # @param step [Symbol, Hash] The step method name
-    def __expand_step_method__(step)
-      return [step] unless step.is_a?(Hash)
-
-      key, value = step.first
-      [key, Array(value).first].compact
+      old_attributes.merge(new_attributes.select { |k, _| k.is_a?(Symbol) })
     end
 
     # Execute active_model validation as a flow step.
@@ -173,6 +119,23 @@ module Fluxo
       self.class.validations_proxy.validate!(self, **attributes)
     end
 
+    # Validates the operation was called with all the required keyword arguments.
+    # @param attributes [Hash] The attributes to validate
+    # @return [Fluxo::Result] The result of the validation
+    # @raise [ArgumentError] When a required attribute is missing
+    def __validate_required_attributes__(**attributes)
+      missing = self.class.required_attributes - attributes.keys
+      return Success(:required_attributes) { nil } if missing.none?
+
+      if self.class.strict?
+        raise ArgumentError, "Missing required attributes: #{missing.join(", ")}"
+      else
+        Failure(:required_attributes) do
+          {error: "Missing required attributes: #{missing.join(", ")}"}
+        end
+      end
+    end
+
     # Wrap the step method result in a Fluxo::Result object.
     #
     # @param result [Fluxo::Result, *Object] The object to wrap

data/lib/fluxo/result.rb

@@ -2,7 +2,8 @@
 
 module Fluxo
   class Result
-    attr_reader :operation, :type, :value, :ids
+    ATTRIBUTES = %i[operation type value ids transient_attributes].freeze
+    attr_reader(*ATTRIBUTES)
 
     # @param options [Hash]
     # @option options [Fluxo::Operation] :operation The operation instance that gererated this result
@@ -14,10 +15,14 @@ module Fluxo
       @value = value
       @type = type
       @ids = Array(ids)
+      @transient_attributes = {}
     end
 
     def mutate(**attrs)
-      self.class.new(**{operation: operation, type: type, value: value, ids: ids}.merge(attrs))
+      attrs.each do |key, value|
+        instance_variable_set("@#{key}", value) if ATTRIBUTES.include?(key)
+      end
+      self
     end
 
     def ==(other)

data/lib/fluxo/rspec.rb

@@ -0,0 +1,172 @@
+require "rspec/expectations"
+
+module Fluxo
+  module Rspec
+    def self.included(klass)
+      klass.send(:include, OperationResultMatchers)
+      klass.send(:include, InstanceMethods)
+    end
+
+    module OperationResultMatchers
+      extend RSpec::Matchers::DSL
+
+      matcher :result_succeed do
+        match do |actual|
+          return false unless actual.is_a?(Fluxo::Result)
+
+          actual.success? && (@expected_value.nil? || values_match?(@expected_value, actual.value))
+        end
+
+        chain :with_value do |value|
+          @expected_value = value
+        end
+
+        def differ
+          RSpec::Support::Differ.new(
+            object_preparer: ->(object) { RSpec::Matchers::Composable.surface_descriptions_in(object) },
+            color: RSpec::Matchers.configuration.color?
+          )
+        end
+
+        failure_message do |actual|
+          return "expected that operation succeed, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          msg = "expected that operation succeed, "
+          msg += if actual.error?
+            format("but the operation errored.\nException:\n %<e>p\n%<t>s", e: actual.value, t: actual.value.backtrace[0..5].join("\n"))
+          elsif actual.failure?
+            "but the operation failed."
+          else
+            "but got success with incorrect value"
+          end
+          if defined?(ActiveModel) && actual.value.is_a?(ActiveModel::Errors) && actual.value.any?
+            msg += "\nActive Model errors:\n"
+            actual.value.full_messages.each { |m| msg += "--> #{m}" }
+          end
+          msg += "\nDiff:" + differ.diff(actual.value, @expected_value) if @expected_value
+          msg
+        end
+
+        failure_message_when_negated do |actual|
+          return "expected that operation not to succeed, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          "expected that operation not to succeed, but the operation succeeded."
+        end
+      end
+
+      matcher :result_fail do # fail is a reserved word
+        match do |actual|
+          return false unless actual.is_a?(Fluxo::Result)
+
+          actual.failure? && (@expected_value.nil? || values_match?(@expected_value, actual.value))
+        end
+
+        chain :with_value do |value|
+          @expected_value = value
+        end
+
+        def differ
+          RSpec::Support::Differ.new(
+            object_preparer: ->(object) { RSpec::Matchers::Composable.surface_descriptions_in(object) },
+            color: RSpec::Matchers.configuration.color?
+          )
+        end
+
+        failure_message do |actual|
+          return "expected that operation fail, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          msg = "expected that operation fail, "
+          if actual.success?
+            msg += "but the operation succeeded."
+            msg += "\nDiff:" + differ.diff(actual.value, @expected_value) if @expected_value
+          elsif actual.error?
+            msg += format("but the operation errored.\nException:\n %<e>p\n%<t>s", e: actual.value, t: actual.value.backtrace[0..5].join("\n"))
+          else
+            msg += "but got failure with incorrect value"
+            msg += "\nDiff:" + differ.diff(actual.value, @expected_value) if @expected_value
+          end
+          if defined?(ActiveModel) && actual.value.is_a?(ActiveModel::Errors) && actual.value.any?
+            msg += "\nActive Model errors:\n"
+            actual.value.full_messages.each { |m| msg += "--> #{m}" }
+          end
+          msg
+        end
+
+        failure_message_when_negated do |actual|
+          return "expected that operation not to fail, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          "expected that operation not to fail, but the operation failed."
+        end
+      end
+
+      matcher :result_error do
+        match do |actual|
+          return false unless actual.is_a?(Fluxo::Result)
+
+          actual.error? && (@expected_value.nil? || values_match?(@expected_value, actual.value))
+        end
+
+        chain :with_value do |value|
+          @expected_value = value
+        end
+
+        failure_message do |actual|
+          return "expected that operation error, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          msg = "expected that operation error, "
+          msg += if actual.success?
+            "but the operation succeeded"
+          elsif actual.failure?
+            "but the operation failed"
+          else
+            "but got error with #{@expected_value&.inspect || "incorrect"} instead of #{actual.value.inspect}"
+          end
+          if defined?(ActiveModel) && actual.value.is_a?(ActiveModel::Errors) && actual.value.any?
+            msg += "\nActive Model errors:\n"
+            actual.value.full_messages.each { |m| msg += "--> #{m}" }
+          end
+          msg
+        end
+
+        failure_message_when_negated do |actual|
+          return "expected that operation not to error, but got invalid result #{actual.inspect}" unless actual.is_a?(Fluxo::Result)
+
+          "expected that operation not to error, but the operation errored."
+        end
+      end
+    end
+
+    module InstanceMethods
+      def expect_operation_result(**attrs)
+        expect(operation_result(**attrs))
+      end
+
+      def operation_result(**kwargs)
+        define_singleton_method(:result) { instance_variable_get(:@__result__) }
+        @__result__ ||= described_class.call(**kwargs)
+      end
+
+      def expect_step_result(step_name, **kwargs)
+        expect(step_result(step_name, **kwargs))
+      end
+
+      def step_result(step_name, **kwargs)
+        @__operation__ = described_class.new
+        define_singleton_method(:result) { instance_variable_get(:@__result__) }
+
+        begin
+          @__result__ = @__operation__.__execute_flow__(steps: [step_name], attributes: kwargs, validate: false)
+        rescue => e
+          @__result__ = Fluxo::Result.new(type: :exception, value: e, operation: @__operation__, ids: %i[error])
+          Fluxo::Errors.raise_operation_error!(result)
+        end
+
+        @__result__
+      end
+    end
+  end
+end
+
+::RSpec.configure do |config|
+  config.include Fluxo::Rspec, type: :operation
+end

data/lib/fluxo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fluxo
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluxo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Marcos G. Zimmermann
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2023-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: standard
@@ -89,8 +89,8 @@ files:
 - lib/fluxo/errors.rb
 - lib/fluxo/operation.rb
 - lib/fluxo/operation/attributes.rb
-- lib/fluxo/operation/constructor.rb
 - lib/fluxo/result.rb
+- lib/fluxo/rspec.rb
 - lib/fluxo/version.rb
 homepage: https://github.com/marcosgz/fluxo
 licenses:
@@ -98,7 +98,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/marcosgz/fluxo
   source_code_uri: https://github.com/marcosgz/fluxo
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,8 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Simple Ruby DSL to create operation service objects.
 test_files: []

data/lib/fluxo/operation/constructor.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Fluxo
-  class Operation
-    module Constructor
-      def self.included(klass)
-        klass.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def inherited(subclass)
-          subclass.instance_variable_set(:@attribute_names, @attribute_names.dup)
-        end
-
-        def def_Operation(op_module)
-          tap do |klass|
-            op_module.define_singleton_method(:Operation) do |*attrs|
-              klass.Operation(*attrs)
-            end
-          end
-        end
-
-        def Operation(*attrs)
-          Class.new(self).tap do |klass|
-            klass.attributes(*attrs)
-          end
-        end
-      end
-    end
-  end
-end