bcdd-result 0.12.0 → 1.0.0

data/lib/bcdd/result.rb

@@ -1,195 +1,29 @@
 # frozen_string_literal: true
 
-require 'singleton'
-
-require_relative 'result/version'
-require_relative 'result/error'
-require_relative 'result/transitions'
-require_relative 'result/callable_and_then'
-require_relative 'result/data'
-require_relative 'result/handler'
-require_relative 'result/failure'
-require_relative 'result/success'
-require_relative 'result/mixin'
-require_relative 'result/contract'
-require_relative 'result/expectations'
-require_relative 'result/context'
-require_relative 'result/config'
-
-class BCDD::Result
-  attr_accessor :unknown, :transitions
-
-  attr_reader :source, :data, :type_checker, :terminal
-
-  protected :source
-
-  private :unknown, :unknown=, :type_checker, :transitions=
-
-  def self.config
-    Config.instance
-  end
-
-  def self.configuration
-    yield(config)
-
-    config.freeze
-  end
-
-  def initialize(type:, value:, source: nil, expectations: nil, terminal: nil)
-    data = Data.new(kind, type, value)
-
-    @type_checker = Contract.evaluate(data, expectations)
-    @source = source
-    @terminal = terminal || kind == :failure
-    @data = data
-
-    self.unknown = true
-    self.transitions = Transitions::Tracking::EMPTY
-
-    Transitions.tracking.record(self)
-  end
-
-  def terminal?
-    terminal
-  end
-
-  def type
-    data.type
-  end
-
-  def value
-    data.value
-  end
-
-  def success?(_type = nil)
-    raise Error::NotImplemented
-  end
-
-  def failure?(_type = nil)
-    raise Error::NotImplemented
-  end
-
-  def value_or(&_block)
-    raise Error::NotImplemented
-  end
-
-  def on(*types, &block)
-    raise Error::MissingTypeArgument if types.empty?
-
-    tap { known(block) if type_checker.allow?(types) }
-  end
-
-  def on_success(*types, &block)
-    tap { known(block) if type_checker.allow_success?(types) && success? }
-  end
-
-  def on_failure(*types, &block)
-    tap { known(block) if type_checker.allow_failure?(types) && failure? }
-  end
-
-  def on_unknown
-    tap { yield(value, type) if unknown }
-  end
-
-  def and_then(method_name = nil, injected_value = nil, &block)
-    return self if terminal?
-
-    method_name && block and raise ::ArgumentError, 'method_name and block are mutually exclusive'
-
-    method_name ? call_and_then_source_method(method_name, injected_value) : call_and_then_block(block)
-  end
-
-  def and_then!(source, injected_value = nil, _call: nil)
-    raise Error::CallableAndThenDisabled unless Config.instance.feature.enabled?(:and_then!)
-
-    return self if terminal?
-
-    call_and_then_callable!(source, value: value, injected_value: injected_value, method_name: _call)
-  end
-
-  def handle
-    handler = Handler.new(self, type_checker: type_checker)
-
-    yield handler
-
-    handler.send(:outcome)
-  end
-
-  def ==(other)
-    self.class == other.class && type == other.type && value == other.value
-  end
-
-  def hash
-    [self.class, type, value].hash
-  end
-
-  def inspect
-    format('#<%<class_name>s type=%<type>p value=%<value>p>', class_name: self.class.name, type: type, value: value)
-  end
-
-  def deconstruct
-    [type, value]
-  end
-
-  def deconstruct_keys(_keys)
-    { kind => { type => value } }
-  end
-
-  alias eql? ==
-  alias on_type on
-
-  private
-
-  def kind
-    :unknown
-  end
-
-  def known(block)
-    self.unknown = false
-
-    block.call(value, type)
-  end
-
-  def call_and_then_source_method(method_name, injected_value)
-    method = source.method(method_name)
-
-    Transitions.tracking.record_and_then(method, injected_value, source) do
-      result = call_and_then_source_method!(method, injected_value)
-
-      ensure_result_object(result, origin: :method)
-    end
-  end
-
-  def call_and_then_source_method!(method, injected_value)
-    case method.arity
-    when 0 then source.send(method.name)
-    when 1 then source.send(method.name, value)
-    when 2 then source.send(method.name, value, injected_value)
-    else raise Error::InvalidSourceMethodArity.build(source: source, method: method, max_arity: 2)
-    end
-  end
-
-  def call_and_then_block(block)
-    Transitions.tracking.record_and_then(:block, nil, source) do
-      result = call_and_then_block!(block)
-
-      ensure_result_object(result, origin: :block)
-    end
-  end
-
-  def call_and_then_block!(block)
-    block.call(value)
-  end
-
-  def call_and_then_callable!(source, value:, injected_value:, method_name:)
-    CallableAndThen::Caller.call(source, value: value, injected_value: injected_value, method_name: method_name)
-  end
-
-  def ensure_result_object(result, origin:)
-    raise Error::UnexpectedOutcome.build(outcome: result, origin: origin) unless result.is_a?(::BCDD::Result)
-
-    return result if result.source.equal?(source)
-
-    raise Error::InvalidResultSource.build(given_result: result, expected_source: source)
+require 'set'
+
+module BCDD
+  require_relative 'success'
+  require_relative 'failure'
+
+  class Result
+    require_relative 'result/version'
+    require_relative 'result/error'
+    require_relative 'result/ignored_types'
+    require_relative 'result/event_logs'
+    require_relative 'result/callable_and_then'
+    require_relative 'result/data'
+    require_relative 'result/handler'
+    require_relative 'result/failure'
+    require_relative 'result/success'
+    require_relative 'result/mixin'
+    require_relative 'result/contract'
+    require_relative 'result/expectations'
+    require_relative 'result/config'
+    require_relative 'result/_self'
+
+    require_relative 'context'
+
+    Context = ::BCDD::Context
   end
 end

data/lib/bcdd/success.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BCDD
+  module Success
+    def success?(type = nil)
+      type.nil? || type_checker.allow_success?([type])
+    end
+
+    def failure?(_type = nil)
+      false
+    end
+
+    def value_or
+      value
+    end
+
+    private
+
+    def kind
+      :success
+    end
+  end
+end

data/sig/bcdd/context.rbs

@@ -0,0 +1,175 @@
+class BCDD::Context < BCDD::Result
+  EXPECTED_OUTCOME: String
+
+  SourceMethodArity: ^(Method) -> Integer
+
+  attr_reader acc: Hash[Symbol, untyped]
+
+  def initialize: (
+    type: Symbol,
+    value: untyped,
+    ?source: untyped,
+    ?expectations: BCDD::Result::Contract::Evaluator,
+    ?terminal: bool
+  ) -> void
+
+  def and_then: (?Symbol, **untyped) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
+
+  def and_then!: (untyped, **untyped) -> untyped
+
+  private
+
+  def call_and_then_source_method: (Symbol, Hash[Symbol, untyped]) -> BCDD::Context
+
+  def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> BCDD::Context
+
+  def ensure_result_object: (untyped, origin: Symbol) -> BCDD::Context
+
+  def raise_unexpected_outcome_error: (BCDD::Context | untyped, Symbol) -> void
+end
+
+class BCDD::Context
+  class Error < BCDD::Result::Error
+    class InvalidExposure < BCDD::Context::Error
+    end
+  end
+end
+
+class BCDD::Context
+  class Success < BCDD::Context
+    include BCDD::Success
+
+    FetchValues: Proc
+
+    def and_expose: (Symbol, Array[Symbol], terminal: bool) -> BCDD::Context::Success
+  end
+
+  def self.Success: (Symbol, **untyped) -> BCDD::Context::Success
+end
+
+module BCDD::Context::CallableAndThen
+  class Caller < BCDD::Result::CallableAndThen::Caller
+    module KeyArgs
+      def self.parameters?: (untyped) -> bool
+
+      def self.invalid_arity: (untyped, Symbol) -> BCDD::Result::CallableAndThen::Error::InvalidArity
+    end
+
+    def self.call: (
+      untyped source,
+      value: untyped,
+      injected_value: untyped,
+      method_name: (Symbol | nil),
+    ) -> BCDD::Context
+
+    private
+
+    def self.call_proc!: (
+      untyped source,
+      Hash[Symbol, untyped] value,
+      nil injected_value
+    ) -> BCDD::Context
+
+    def self.call_method!: (
+      untyped source,
+      Method method,
+      Hash[Symbol, untyped] value,
+      nil injected_value
+    ) -> BCDD::Context
+
+    def self.callable_method: (
+      untyped source,
+      (Symbol | nil) method_name
+    ) -> ::Method
+
+    def self.ensure_result_object: (
+      untyped source,
+      untyped value,
+      BCDD::Context result
+    ) -> BCDD::Context
+
+    def self.expected_result_object: () -> singleton(BCDD::Context)
+
+    def self.expected_outcome: () -> String
+  end
+end
+
+class BCDD::Context
+  class Failure < BCDD::Context
+    include BCDD::Failure
+
+    def and_expose: (Symbol, Array[Symbol], **untyped) -> BCDD::Context::Failure
+  end
+
+  def self.Failure: (Symbol, **untyped) -> BCDD::Context::Failure
+end
+
+class BCDD::Context
+  module Mixin
+    Factory: singleton(BCDD::Result::Mixin::Factory)
+
+    module Methods
+      def Success: (Symbol, **untyped) -> BCDD::Context::Success
+
+      def Failure: (Symbol, **untyped) -> BCDD::Context::Failure
+
+      private
+
+      def _ResultAs: (singleton(BCDD::Context), Symbol, untyped, ?terminal: bool) -> untyped
+    end
+
+    module Addons
+      module Continue
+        include BCDD::Context::Mixin::Methods
+
+        private
+
+        def Continue: (**untyped) -> BCDD::Context::Success
+      end
+
+      module Given
+        include BCDD::Context::Mixin::Methods
+
+        private
+
+        def Given: (*untyped) -> BCDD::Context::Success
+      end
+
+      OPTIONS: Hash[Symbol, Module]
+
+      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
+    end
+  end
+
+  def self.mixin_module: -> singleton(BCDD::Context::Mixin)
+
+  def self.result_factory: -> singleton(BCDD::Context)
+end
+
+class BCDD::Context::Expectations < BCDD::Result::Expectations
+  def self.mixin_module: -> singleton(BCDD::Context::Expectations::Mixin)
+
+  def self.result_factory_without_expectations: -> singleton(BCDD::Result)
+
+  def Success: (Symbol, **untyped) -> BCDD::Context::Success
+  def Failure: (Symbol, **untyped) -> BCDD::Context::Failure
+end
+
+module BCDD::Context::Expectations::Mixin
+  Methods: singleton(BCDD::Result::Expectations::Mixin::Methods)
+  Factory: singleton(BCDD::Result::Expectations::Mixin::Factory)
+
+  module Addons
+    module Continue
+      private def Continue: (**untyped) -> BCDD::Context::Success
+    end
+
+    module Given
+      private def Given: (*untyped) -> BCDD::Context::Success
+    end
+
+    OPTIONS: Hash[Symbol, Module]
+
+    def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
+  end
+end

data/sig/bcdd/failure.rbs

@@ -0,0 +1,13 @@
+module BCDD
+  module Failure
+    def success?: (?Symbol type) -> bool
+    def failure?: (?Symbol type) -> bool
+    def value_or: { (untyped) -> untyped } -> untyped
+    def value: -> untyped
+
+    private
+
+    def kind: -> Symbol
+    def type_checker: -> BCDD::Result::Contract::TypeChecker
+  end
+end

data/sig/bcdd/result/config.rbs

@@ -1,6 +1,4 @@
 class BCDD::Result::Config
-  include Singleton
-
   ADDON: Hash[Symbol, Hash[Symbol, untyped]]
   FEATURE: Hash[Symbol, Hash[Symbol, untyped]]
   PATTERN_MATCHING: Hash[Symbol, Hash[Symbol, untyped]]
@@ -15,6 +13,7 @@ class BCDD::Result::Config
   def initialize: -> void
 
   def and_then!: () -> BCDD::Result::CallableAndThen::Config
+  def event_logs: () -> BCDD::Result::EventLogs::Config
 
   def freeze: -> BCDD::Result::Config
   def options: -> Hash[Symbol, BCDD::Result::Config::Switcher]

data/sig/bcdd/result/context.rbs

@@ -1,166 +1,3 @@
-class BCDD::Result::Context < BCDD::Result
-  EXPECTED_OUTCOME: String
-
-  SourceMethodArity: ^(Method) -> Integer
-
-  attr_reader acc: Hash[Symbol, untyped]
-
-  def initialize: (
-    type: Symbol,
-    value: untyped,
-    ?source: untyped,
-    ?expectations: BCDD::Result::Contract::Evaluator,
-    ?terminal: bool
-  ) -> void
-
-  def and_then: (?Symbol, **untyped) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
-
-  def and_then!: (untyped, **untyped) -> untyped
-
-  private
-
-  def call_and_then_source_method: (Symbol, Hash[Symbol, untyped]) -> BCDD::Result::Context
-
-  def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> BCDD::Result::Context
-
-  def ensure_result_object: (untyped, origin: Symbol) -> BCDD::Result::Context
-
-  def raise_unexpected_outcome_error: (BCDD::Result::Context | untyped, Symbol) -> void
-end
-
-class BCDD::Result::Context
-  class Success < BCDD::Result::Context
-    include BCDD::Result::Success::Methods
-
-    def and_expose: (Symbol, Array[Symbol], terminal: bool) -> BCDD::Result::Context::Success
-  end
-
-  def self.Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
-end
-
-module BCDD::Result::Context::CallableAndThen
-  class Caller < BCDD::Result::CallableAndThen::Caller
-    module KeyArgs
-      def self.parameters?: (untyped) -> bool
-
-      def self.invalid_arity: (untyped, Symbol) -> BCDD::Result::CallableAndThen::Error::InvalidArity
-    end
-
-    def self.call: (
-      untyped source,
-      value: untyped,
-      injected_value: untyped,
-      method_name: (Symbol | nil),
-    ) -> BCDD::Result::Context
-
-    private
-
-    def self.call_proc!: (
-      untyped source,
-      Hash[Symbol, untyped] value,
-      nil injected_value
-    ) -> BCDD::Result::Context
-
-    def self.call_method!: (
-      untyped source,
-      Method method,
-      Hash[Symbol, untyped] value,
-      nil injected_value
-    ) -> BCDD::Result::Context
-
-    def self.callable_method: (
-      untyped source,
-      (Symbol | nil) method_name
-    ) -> ::Method
-
-    def self.ensure_result_object: (
-      untyped source,
-      untyped value,
-      BCDD::Result::Context result
-    ) -> BCDD::Result::Context
-
-    def self.expected_result_object: () -> singleton(BCDD::Result::Context)
-
-    def self.expected_outcome: () -> String
-  end
-end
-
-class BCDD::Result::Context
-  class Failure < BCDD::Result::Context
-    include BCDD::Result::Failure::Methods
-
-    def and_expose: (Symbol, Array[Symbol], **untyped) -> BCDD::Result::Context::Failure
-  end
-
-  def self.Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
-end
-
-class BCDD::Result::Context
-  module Mixin
-    Factory: singleton(BCDD::Result::Mixin::Factory)
-
-    module Methods
-      def Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
-
-      def Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
-
-      private
-
-      def _ResultAs: (singleton(BCDD::Result::Context), Symbol, untyped, ?terminal: bool) -> untyped
-    end
-
-    module Addons
-      module Continue
-        include BCDD::Result::Context::Mixin::Methods
-
-        private
-
-        def Continue: (**untyped) -> BCDD::Result::Context::Success
-      end
-
-      module Given
-        include BCDD::Result::Context::Mixin::Methods
-
-        private
-
-        def Given: (*untyped) -> BCDD::Result::Context::Success
-      end
-
-      OPTIONS: Hash[Symbol, Module]
-
-      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
-    end
-  end
-
-  def self.mixin_module: -> singleton(BCDD::Result::Context::Mixin)
-
-  def self.result_factory: -> singleton(BCDD::Result::Context)
-end
-
-class BCDD::Result::Context::Expectations < BCDD::Result::Expectations
-  def self.mixin_module: -> singleton(BCDD::Result::Context::Expectations::Mixin)
-
-  def self.result_factory_without_expectations: -> singleton(BCDD::Result)
-
-  def Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
-  def Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
-end
-
-module BCDD::Result::Context::Expectations::Mixin
-  Methods: singleton(BCDD::Result::Expectations::Mixin::Methods)
-  Factory: singleton(BCDD::Result::Expectations::Mixin::Factory)
-
-  module Addons
-    module Continue
-      private def Continue: (**untyped) -> BCDD::Result::Context::Success
-    end
-
-    module Given
-      private def Given: (*untyped) -> BCDD::Result::Context::Success
-    end
-
-    OPTIONS: Hash[Symbol, Module]
-
-    def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
-  end
+class BCDD::Result
+  Context: BCDD::Context
 end

data/sig/bcdd/result/contract.rbs

@@ -26,6 +26,7 @@ module BCDD::Result::Contract
       expectations: BCDD::Result::Contract::Evaluator
     ) -> void
 
+    def allow!: (Symbol) -> Symbol
     def allow?: (Array[Symbol]) -> bool
     def allow_success?: (Array[Symbol]) -> bool
     def allow_failure?: (Array[Symbol]) -> bool