bcdd-result 0.11.0 → 0.13.0

data/lib/bcdd/result/context/mixin.rb

@@ -14,7 +14,7 @@ class BCDD::Result::Context
       end
 
       private def _ResultAs(kind_class, type, value, terminal: nil)
-        kind_class.new(type: type, value: value, subject: self, terminal: terminal)
+        kind_class.new(type: type, value: value, source: self, terminal: terminal)
       end
     end
 
@@ -25,7 +25,7 @@ class BCDD::Result::Context
         end
 
         private def Continue(**value)
-          _ResultAs(Success, :continued, value)
+          _ResultAs(Success, ::BCDD::Result::IgnoredTypes::CONTINUE, value)
         end
       end
 
@@ -33,7 +33,7 @@ class BCDD::Result::Context
         private def Given(*values)
           value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
 
-          _ResultAs(Success, :given, value)
+          _ResultAs(Success, ::BCDD::Result::IgnoredTypes::GIVEN, value)
         end
       end
 

data/lib/bcdd/result/context/success.rb

@@ -1,15 +1,37 @@
 # frozen_string_literal: true
 
-class BCDD::Result::Context::Success < BCDD::Result::Context
-  include ::BCDD::Result::Success::Methods
+class BCDD::Result
+  class Context::Error < BCDD::Result::Error
+    InvalidExposure = ::Class.new(self)
+  end
+
+  class Context::Success < Context
+    include ::BCDD::Result::Success::Methods
+
+    FetchValues = ->(acc_values, keys) do
+      fetched_values = acc_values.fetch_values(*keys)
 
-  def and_expose(type, keys, terminal: true)
-    unless keys.is_a?(::Array) && !keys.empty? && keys.all?(::Symbol)
-      raise ::ArgumentError, 'keys must be an Array of Symbols'
+      keys.zip(fetched_values).to_h
+    rescue ::KeyError => e
+      message = "#{e.message}. Available to expose: #{acc_values.keys.map(&:inspect).join(', ')}"
+
+      raise Context::Error::InvalidExposure, message
     end
 
-    exposed_value = acc.merge(value).slice(*keys)
+    def and_expose(type, keys, terminal: true)
+      unless keys.is_a?(::Array) && !keys.empty? && keys.all?(::Symbol)
+        raise ::ArgumentError, 'keys must be an Array of Symbols'
+      end
+
+      Transitions.tracking.reset_and_then!
 
-    self.class.new(type: type, value: exposed_value, subject: subject, terminal: terminal)
+      acc_values = acc.merge(value)
+
+      value_to_expose = FetchValues.call(acc_values, keys)
+
+      expectations = type_checker.expectations
+
+      self.class.new(type: type, value: value_to_expose, source: source, terminal: terminal, expectations: expectations)
+    end
   end
 end

data/lib/bcdd/result/context.rb

@@ -6,6 +6,9 @@ class BCDD::Result
     require_relative 'context/success'
     require_relative 'context/mixin'
     require_relative 'context/expectations'
+    require_relative 'context/callable_and_then'
+
+    EXPECTED_OUTCOME = 'BCDD::Result::Context::Success or BCDD::Result::Context::Failure'
 
     def self.Success(type, **value)
       Success.new(type: type, value: value)
@@ -15,7 +18,7 @@ class BCDD::Result
       Failure.new(type: type, value: value)
     end
 
-    def initialize(type:, value:, subject: nil, expectations: nil, terminal: nil)
+    def initialize(type:, value:, source: nil, expectations: nil, terminal: nil)
       value.is_a?(::Hash) or raise ::ArgumentError, 'value must be a Hash'
 
       @acc = {}
@@ -23,8 +26,16 @@ class BCDD::Result
       super
     end
 
-    def and_then(method_name = nil, **context_data, &block)
-      super(method_name, context_data, &block)
+    def and_then(method_name = nil, **injected_value, &block)
+      super(method_name, injected_value, &block)
+    end
+
+    def and_then!(source, **injected_value)
+      _call = injected_value.delete(:_call)
+
+      acc.merge!(injected_value)
+
+      super(source, injected_value, _call: _call)
     end
 
     protected
@@ -33,20 +44,23 @@ class BCDD::Result
 
     private
 
-    SubjectMethodArity = ->(method) do
+    SourceMethodArity = ->(method) do
       return 0 if method.arity.zero?
-      return 1 if method.parameters.map(&:first).all?(/\Akey/)
+
+      parameters = method.parameters.map(&:first)
+
+      return 1 if !parameters.empty? && parameters.all?(/\Akey/)
 
       -1
     end
 
-    def call_and_then_subject_method!(method, context_data)
-      acc.merge!(value.merge(context_data))
+    def call_and_then_source_method!(method, injected_value)
+      acc.merge!(value.merge(injected_value))
 
-      case SubjectMethodArity[method]
-      when 0 then subject.send(method.name)
-      when 1 then subject.send(method.name, **acc)
-      else raise Error::InvalidSubjectMethodArity.build(subject: subject, method: method, max_arity: 1)
+      case SourceMethodArity[method]
+      when 0 then source.send(method.name)
+      when 1 then source.send(method.name, **acc)
+      else raise Error::InvalidSourceMethodArity.build(source: source, method: method, max_arity: 1)
       end
     end
 
@@ -56,20 +70,24 @@ class BCDD::Result
       block.call(acc)
     end
 
+    def call_and_then_callable!(source, value:, injected_value:, method_name:)
+      acc.merge!(value.merge(injected_value))
+
+      CallableAndThen::Caller.call(source, value: acc, injected_value: injected_value, method_name: method_name)
+    end
+
     def ensure_result_object(result, origin:)
       raise_unexpected_outcome_error(result, origin) unless result.is_a?(Context)
 
-      return result.tap { _1.acc.merge!(acc) } if result.subject.equal?(subject)
+      return result.tap { _1.acc.merge!(acc) } if result.source.equal?(source)
 
-      raise Error::InvalidResultSubject.build(given_result: result, expected_subject: subject)
+      raise Error::InvalidResultSource.build(given_result: result, expected_source: source)
     end
 
-    EXPECTED_OUTCOME = 'BCDD::Result::Context::Success or BCDD::Result::Context::Failure'
-
     def raise_unexpected_outcome_error(result, origin)
       raise Error::UnexpectedOutcome.build(outcome: result, origin: origin, expected: EXPECTED_OUTCOME)
     end
 
-    private_constant :SubjectMethodArity, :EXPECTED_OUTCOME
+    private_constant :SourceMethodArity
   end
 end

data/lib/bcdd/result/contract/for_types.rb

@@ -11,7 +11,7 @@ class BCDD::Result
     end
 
     def type?(type)
-      allowed_types.member?(type)
+      IgnoredTypes.include?(type) || allowed_types.member?(type)
     end
 
     def type!(type)

data/lib/bcdd/result/contract/for_types_and_values.rb

@@ -30,6 +30,8 @@ class BCDD::Result
     def type_and_value!(data)
       type, value = data.type, data.value
 
+      return value if IgnoredTypes.include?(type)
+
       value_checking = @types_and_values[type!(type)]
 
       checking_result = value_checking === value

data/lib/bcdd/result/error.rb

@@ -9,7 +9,7 @@ class BCDD::Result::Error < StandardError
   end
 
   class MissingTypeArgument < self
-    def initialize(_arg = nil)
+    def initialize(_message = nil)
       super('A type (argument) is required to invoke the #on/#on_type method')
     end
   end
@@ -22,29 +22,38 @@ class BCDD::Result::Error < StandardError
     end
   end
 
-  class InvalidResultSubject < self
-    def self.build(given_result:, expected_subject:)
+  class InvalidResultSource < self
+    def self.build(given_result:, expected_source:)
       message =
-        "You cannot call #and_then and return a result that does not belong to the subject!\n" \
-        "Expected subject: #{expected_subject.inspect}\n" \
-        "Given subject: #{given_result.send(:subject).inspect}\n" \
+        "You cannot call #and_then and return a result that does not belong to the same source!\n" \
+        "Expected source: #{expected_source.inspect}\n" \
+        "Given source: #{given_result.send(:source).inspect}\n" \
         "Given result: #{given_result.inspect}"
 
       new(message)
     end
   end
 
-  class InvalidSubjectMethodArity < self
-    def self.build(subject:, method:, max_arity:)
-      new("#{subject.class}##{method.name} has unsupported arity (#{method.arity}). Expected 0..#{max_arity}")
+  class InvalidSourceMethodArity < self
+    def self.build(source:, method:, max_arity:)
+      new("#{source.class}##{method.name} has unsupported arity (#{method.arity}). Expected 0..#{max_arity}")
     end
   end
 
   class UnhandledTypes < self
     def self.build(types:)
-      subject = types.size == 1 ? 'This was' : 'These were'
+      source = types.size == 1 ? 'This was' : 'These were'
 
-      new("You must handle all cases. #{subject} not handled: #{types.map(&:inspect).join(', ')}")
+      new("You must handle all cases. #{source} not handled: #{types.map(&:inspect).join(', ')}")
+    end
+  end
+
+  class CallableAndThenDisabled < self
+    def initialize(_message = nil)
+      super(
+        'You cannot use #and_then! as the feature is disabled. ' \
+        'Please use BCDD::Result.config.feature.enable!(:and_then!) to enable it.'
+      )
     end
   end
 end

data/lib/bcdd/result/expectations/mixin.rb

@@ -24,7 +24,7 @@ class BCDD::Result
 
       FACTORY = <<~RUBY
         private def _Result
-          @_Result ||= Result.with(subject: self, terminal: %<terminal>s)
+          @_Result ||= Result.with(source: self, terminal: %<terminal>s)
         end
       RUBY
 
@@ -38,13 +38,13 @@ class BCDD::Result
     module Addons
       module Continue
         private def Continue(value)
-          Success.new(type: :continued, value: value, subject: self)
+          _Result.Success(IgnoredTypes::CONTINUE, value)
         end
       end
 
       module Given
         private def Given(value)
-          Success.new(type: :given, value: value, subject: self)
+          _Result.Success(IgnoredTypes::GIVEN, value)
         end
       end
 

data/lib/bcdd/result/expectations.rb

@@ -38,10 +38,10 @@ class BCDD::Result
 
     private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
 
-    def initialize(subject: nil, contract: nil, terminal: nil, **options)
+    def initialize(source: nil, contract: nil, terminal: nil, **options)
       @terminal = terminal
 
-      @subject = subject
+      @source = source
 
       @contract = contract if contract.is_a?(Contract::Evaluator)
 
@@ -60,16 +60,16 @@ class BCDD::Result
       _ResultAs(Failure, type, value)
     end
 
-    def with(subject:, terminal: nil)
-      self.class.new(subject: subject, terminal: terminal, contract: contract)
+    def with(source:, terminal: nil)
+      self.class.new(source: source, terminal: terminal, contract: contract)
     end
 
     private
 
     def _ResultAs(kind_class, type, value)
-      kind_class.new(type: type, value: value, subject: subject, expectations: contract, terminal: terminal)
+      kind_class.new(type: type, value: value, source: source, expectations: contract, terminal: terminal)
     end
 
-    attr_reader :subject, :terminal, :contract
+    attr_reader :source, :terminal, :contract
   end
 end

data/lib/bcdd/result/ignored_types.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  module IgnoredTypes
+    LIST = ::Set[
+      GIVEN = :_given_,
+      CONTINUE = :_continue_
+    ].freeze
+
+    def self.include?(type)
+      LIST.member?(type)
+    end
+  end
+end

data/lib/bcdd/result/mixin.rb

@@ -21,7 +21,7 @@ class BCDD::Result
       end
 
       private def _ResultAs(kind_class, type, value, terminal: nil)
-        kind_class.new(type: type, value: value, subject: self, terminal: terminal)
+        kind_class.new(type: type, value: value, source: self, terminal: terminal)
       end
     end
 
@@ -32,13 +32,13 @@ class BCDD::Result
         end
 
         private def Continue(value)
-          _ResultAs(Success, :continued, value)
+          _ResultAs(Success, IgnoredTypes::CONTINUE, value)
         end
       end
 
       module Given
         private def Given(value)
-          _ResultAs(Success, :given, value)
+          _ResultAs(Success, IgnoredTypes::GIVEN, value)
         end
       end
 

data/lib/bcdd/result/transitions/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BCDD::Result::Transitions
+  class Config
+    include ::Singleton
+
+    attr_reader :listener, :trace_id
+
+    def initialize
+      @trace_id = -> {}
+      @listener = Listener::Null.new
+    end
+
+    def listener=(arg)
+      Listener.kind?(arg) or raise ::ArgumentError, "#{arg.inspect} must be a #{Listener}"
+
+      @listener = arg
+    end
+
+    def trace_id=(arg)
+      raise ::ArgumentError, 'must be a lambda with arity 0' unless arg.is_a?(::Proc) && arg.lambda? && arg.arity.zero?
+
+      @trace_id = arg
+    end
+  end
+end

data/lib/bcdd/result/transitions/listener.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module BCDD::Result::Transitions
+  module Listener
+    module ClassMethods
+      def around_transitions?
+        false
+      end
+
+      def around_and_then?
+        false
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.kind?(arg)
+      (arg.is_a?(::Class) && arg < self) || (arg.is_a?(::Module) && arg.is_a?(self)) || arg.is_a?(Listeners::Chain)
+    end
+
+    def on_start(scope:); end
+
+    def around_transitions(scope:)
+      yield
+    end
+
+    def around_and_then(scope:, and_then:)
+      yield
+    end
+
+    def on_record(record:); end
+
+    def on_finish(transitions:); end
+
+    def before_interruption(exception:, transitions:); end
+  end
+
+  module Listener::Null
+    extend Listener
+
+    def self.new
+      self
+    end
+  end
+end

data/lib/bcdd/result/transitions/listeners.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module BCDD::Result::Transitions
+  class Listeners
+    class Chain
+      include Listener
+
+      attr_reader :listeners
+
+      def initialize(list)
+        if list.empty? || list.any? { !Listener.kind?(_1) }
+          raise ArgumentError, "listeners must be a list of #{Listener}"
+        end
+
+        around_and_then = list.select(&:around_and_then?)
+        around_transitions = list.select(&:around_transitions?)
+
+        raise ArgumentError, 'only one listener can have around_and_then? == true' if around_and_then.size > 1
+        raise ArgumentError, 'only one listener can have around_transitions? == true' if around_transitions.size > 1
+
+        @listeners = { list: list, around_and_then: around_and_then[0], around_transitions: around_transitions[0] }
+      end
+
+      def new
+        list, around_and_then, around_transitions = listeners[:list], nil, nil
+
+        instances = list.map do |item|
+          instance = item.new
+          around_and_then = instance if listener?(:around_and_then, instance)
+          around_transitions = instance if listener?(:around_transitions, instance)
+
+          instance
+        end
+
+        list.one? ? list[0].new : Listeners.send(:new, instances, around_and_then, around_transitions)
+      end
+
+      private
+
+      def listener?(name, obj)
+        listener = listeners[name]
+
+        !listener.nil? && (obj.is_a?(listener) || obj == listener)
+      end
+    end
+
+    private_class_method :new
+
+    def self.[](*listeners)
+      Chain.new(listeners)
+    end
+
+    attr_reader :listeners, :around_and_then_listener, :around_transitions_listener
+
+    private :listeners, :around_and_then_listener, :around_transitions_listener
+
+    def initialize(listeners, around_and_then_listener, around_transitions_listener)
+      @listeners = listeners
+      @around_and_then_listener = around_and_then_listener || Listener::Null
+      @around_transitions_listener = around_transitions_listener || Listener::Null
+    end
+
+    def on_start(scope:)
+      listeners.each { _1.on_start(scope: scope) }
+    end
+
+    def around_transitions(scope:, &block)
+      around_transitions_listener.around_transitions(scope: scope, &block)
+    end
+
+    def around_and_then(scope:, and_then:, &block)
+      around_and_then_listener.around_and_then(scope: scope, and_then: and_then, &block)
+    end
+
+    def on_record(record:)
+      listeners.each { _1.on_record(record: record) }
+    end
+
+    def on_finish(transitions:)
+      listeners.each { _1.on_finish(transitions: transitions) }
+    end
+
+    def before_interruption(exception:, transitions:)
+      listeners.each { _1.before_interruption(exception: exception, transitions: transitions) }
+    end
+  end
+end

data/lib/bcdd/result/transitions/tracking/disabled.rb

@@ -2,15 +2,13 @@
 
 module BCDD::Result::Transitions
   module Tracking::Disabled
-    def self.start(name:, desc:); end
-
-    def self.finish(result:); end
-
-    def self.reset!; end
+    def self.exec(_name, _desc)
+      EnsureResult[yield]
+    end
 
     def self.record(result); end
 
-    def self.record_and_then(_type, _data, _subject)
+    def self.record_and_then(_type, _data)
       yield
     end
   end