bcdd-result 0.13.0 → 1.0.0

data/lib/bcdd/result/config.rb

@@ -9,8 +9,6 @@ require_relative 'config/switchers/pattern_matching'
 
 class BCDD::Result
   class Config
-    include ::Singleton
-
     attr_reader :addon, :feature, :constant_alias, :pattern_matching
 
     def initialize
@@ -21,8 +19,8 @@ class BCDD::Result
       @and_then_ = CallableAndThen::Config.new
     end
 
-    def transitions
-      Transitions::Config.instance
+    def event_logs
+      EventLogs::Config.instance
     end
 
     def and_then!
@@ -35,7 +33,7 @@ class BCDD::Result
       constant_alias.freeze
       pattern_matching.freeze
       and_then!.freeze
-      transitions.freeze
+      event_logs.freeze
 
       super
     end
@@ -58,5 +56,9 @@ class BCDD::Result
         "options=#{options.keys.sort.inspect} " \
         "and_then!=#{and_then!.options.inspect}>"
     end
+
+    @instance = new
+
+    singleton_class.send(:attr_reader, :instance)
   end
 end

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

@@ -10,6 +10,10 @@ module BCDD::Result::Contract
       @expectations = expectations
     end
 
+    def allow!(type)
+      expectations.type!(type)
+    end
+
     def allow?(types)
       validate(types, expected: expectations, allow_empty: false)
     end

data/lib/bcdd/result/{transitions → event_logs}/config.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-module BCDD::Result::Transitions
+module BCDD::Result::EventLogs
   class Config
-    include ::Singleton
-
     attr_reader :listener, :trace_id
 
     def initialize
@@ -22,5 +20,9 @@ module BCDD::Result::Transitions
 
       @trace_id = arg
     end
+
+    @instance = new
+
+    singleton_class.send(:attr_reader, :instance)
   end
 end

data/lib/bcdd/result/{transitions → event_logs}/listener.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module BCDD::Result::Transitions
+module BCDD::Result::EventLogs
   module Listener
     module ClassMethods
-      def around_transitions?
+      def around_event_logs?
         false
       end
 
@@ -26,7 +26,7 @@ module BCDD::Result::Transitions
 
     def on_start(scope:); end
 
-    def around_transitions(scope:)
+    def around_event_logs(scope:)
       yield
     end
 
@@ -36,9 +36,9 @@ module BCDD::Result::Transitions
 
     def on_record(record:); end
 
-    def on_finish(transitions:); end
+    def on_finish(event_logs:); end
 
-    def before_interruption(exception:, transitions:); end
+    def before_interruption(exception:, event_logs:); end
   end
 
   module Listener::Null

data/lib/bcdd/result/{transitions → event_logs}/listeners.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module BCDD::Result::Transitions
+module BCDD::Result::EventLogs
   class Listeners
     class Chain
       include Listener
@@ -13,26 +13,26 @@ module BCDD::Result::Transitions
         end
 
         around_and_then = list.select(&:around_and_then?)
-        around_transitions = list.select(&:around_transitions?)
+        around_event_logs = list.select(&:around_event_logs?)
 
         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
+        raise ArgumentError, 'only one listener can have around_event_logs? == true' if around_event_logs.size > 1
 
-        @listeners = { list: list, around_and_then: around_and_then[0], around_transitions: around_transitions[0] }
+        @listeners = { list: list, around_and_then: around_and_then[0], around_event_logs: around_event_logs[0] }
       end
 
       def new
-        list, around_and_then, around_transitions = listeners[:list], nil, nil
+        list, around_and_then, around_event_logs = 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)
+          around_event_logs = instance if listener?(:around_event_logs, instance)
 
           instance
         end
 
-        list.one? ? list[0].new : Listeners.send(:new, instances, around_and_then, around_transitions)
+        list.one? ? list[0].new : Listeners.send(:new, instances, around_and_then, around_event_logs)
       end
 
       private
@@ -50,22 +50,22 @@ module BCDD::Result::Transitions
       Chain.new(listeners)
     end
 
-    attr_reader :listeners, :around_and_then_listener, :around_transitions_listener
+    attr_reader :listeners, :around_and_then_listener, :around_event_logs_listener
 
-    private :listeners, :around_and_then_listener, :around_transitions_listener
+    private :listeners, :around_and_then_listener, :around_event_logs_listener
 
-    def initialize(listeners, around_and_then_listener, around_transitions_listener)
+    def initialize(listeners, around_and_then_listener, around_event_logs_listener)
       @listeners = listeners
       @around_and_then_listener = around_and_then_listener || Listener::Null
-      @around_transitions_listener = around_transitions_listener || Listener::Null
+      @around_event_logs_listener = around_event_logs_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)
+    def around_event_logs(scope:, &block)
+      around_event_logs_listener.around_event_logs(scope: scope, &block)
     end
 
     def around_and_then(scope:, and_then:, &block)
@@ -76,12 +76,12 @@ module BCDD::Result::Transitions
       listeners.each { _1.on_record(record: record) }
     end
 
-    def on_finish(transitions:)
-      listeners.each { _1.on_finish(transitions: transitions) }
+    def on_finish(event_logs:)
+      listeners.each { _1.on_finish(event_logs: event_logs) }
     end
 
-    def before_interruption(exception:, transitions:)
-      listeners.each { _1.before_interruption(exception: exception, transitions: transitions) }
+    def before_interruption(exception:, event_logs:)
+      listeners.each { _1.before_interruption(exception: exception, event_logs: event_logs) }
     end
   end
 end

data/lib/bcdd/result/{transitions → event_logs}/tracking/disabled.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module BCDD::Result::Transitions
+module BCDD::Result::EventLogs
   module Tracking::Disabled
     def self.exec(_name, _desc)
       EnsureResult[yield]

data/lib/bcdd/result/{transitions → event_logs}/tracking/enabled.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-module BCDD::Result::Transitions
+module BCDD::Result::EventLogs
   class Tracking::Enabled
     attr_accessor :tree, :records, :root_started_at, :listener
 
     private :tree, :tree=, :records, :records=, :root_started_at, :root_started_at=, :listener, :listener=
 
     def exec(name, desc)
-      transition_node, scope = start(name, desc)
+      event_log_node, scope = start(name, desc)
 
       result = nil
 
-      listener.around_transitions(scope: scope) do
+      listener.around_event_logs(scope: scope) do
         result = EnsureResult[yield]
       end
 
-      tree.move_to_root! if transition_node.root?
+      tree.move_to_root! if event_log_node.root?
 
       finish(result)
 
       result
     rescue ::Exception => e
-      err!(e, transition_node)
+      err!(e, event_log_node)
     end
 
-    def err!(exception, transition_node)
-      if transition_node.root?
-        listener.before_interruption(exception: exception, transitions: map_transitions)
+    def err!(exception, event_log_node)
+      if event_log_node.root?
+        listener.before_interruption(exception: exception, event_logs: map_event_logs)
 
         reset!
       end
@@ -90,11 +90,11 @@ module BCDD::Result::Transitions
 
       return unless node.root?
 
-      transitions = map_transitions
+      event_logs = map_event_logs
 
-      result.send(:transitions=, transitions)
+      result.send(:event_logs=, event_logs)
 
-      listener.on_finish(transitions: transitions)
+      listener.on_finish(event_logs: event_logs)
 
       reset!
     end
@@ -136,12 +136,14 @@ module BCDD::Result::Transitions
       ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
     end
 
-    def map_transitions
+    def map_event_logs
       duration = (now_in_milliseconds - root_started_at)
 
       trace_id = Config.instance.trace_id.call
 
-      metadata = { duration: duration, ids_tree: tree.nested_ids, ids_matrix: tree.ids_matrix, trace_id: trace_id }
+      ids = { tree: tree.ids, matrix: tree.ids_matrix, level_parent: tree.ids_level_parent }
+
+      metadata = { duration: duration, trace_id: trace_id, ids: ids }
 
       { version: Tracking::VERSION, records: records, metadata: metadata }
     end

data/lib/bcdd/result/{transitions → event_logs}/tracking.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class BCDD::Result
-  module Transitions
+  module EventLogs
     module Tracking
       require_relative 'tracking/enabled'
       require_relative 'tracking/disabled'
@@ -11,14 +11,15 @@ class BCDD::Result
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
       EMPTY_TREE = Tree.new(nil).freeze
+      EMPTY_IDS = { tree: EMPTY_ARRAY, matrix: EMPTY_HASH, level_parent: EMPTY_HASH }.freeze
       EMPTY = {
         version: VERSION,
         records: EMPTY_ARRAY,
-        metadata: { duration: 0, ids_tree: EMPTY_ARRAY, ids_matrix: EMPTY_HASH, trace_id: nil }.freeze
+        metadata: { duration: 0, ids: EMPTY_IDS, trace_id: nil }.freeze
       }.freeze
 
       def self.instance
-        ::BCDD::Result::Config.instance.feature.enabled?(:transitions) ? Tracking::Enabled.new : Tracking::Disabled
+        ::BCDD::Result::Config.instance.feature.enabled?(:event_logs) ? Tracking::Enabled.new : Tracking::Disabled
       end
     end
   end

data/lib/bcdd/result/{transitions → event_logs}/tree.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class BCDD::Result
-  module Transitions
+  module EventLogs
     class Tree
       class Node
         attr_reader :id, :value, :parent, :normalizer, :children
@@ -89,13 +89,17 @@ class BCDD::Result
         move_to!(root)
       end
 
-      NestedIds = ->(node) { [node.id, node.children.map(&NestedIds)] }
+      Ids = ->(node) { [node.id, node.children.map(&Ids)] }
 
-      def nested_ids
-        NestedIds[root]
+      def ids
+        Ids[root]
       end
 
-      IdsMatrix = ->(tree, row, col, ids, previous) do
+      def ids_list
+        ids.flatten
+      end
+
+      IdsMatrix = ->(tree, row, col, memo, previous) do
         last_row = previous[0]
 
         tree.each_with_index do |node, index|
@@ -103,22 +107,34 @@ class BCDD::Result
 
           id, leaf = node
 
-          ids[id] = previous == [row, col] ? [row, col + 1] : [row, col]
+          memo[id] = previous == [row, col] ? [row, col + 1] : [row, col]
 
-          previous = ids[id]
+          previous = memo[id]
 
-          IdsMatrix[leaf, row, col + 1, ids, previous]
+          IdsMatrix[leaf, row, col + 1, memo, previous]
         end
       end
 
       def ids_matrix
         current = [0, 0]
 
-        ids = { 0 => current }
+        memo = { 0 => current }
+
+        IdsMatrix[ids[1], 1, 1, memo, current]
+
+        memo
+      end
+
+      IdsLevelParent = ->((id, node), parent = 0, level = 0, memo = {}) do
+        memo[id] = [level, parent]
 
-        IdsMatrix[nested_ids[1], 1, 1, ids, current]
+        node.each { |leaf| IdsLevelParent[leaf, id, level + 1, memo] }
+
+        memo
+      end
 
-        ids
+      def ids_level_parent
+        IdsLevelParent[ids]
       end
     end
   end

data/lib/bcdd/result/event_logs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  module EventLogs
+    require_relative 'event_logs/listener'
+    require_relative 'event_logs/listeners'
+    require_relative 'event_logs/config'
+    require_relative 'event_logs/tree'
+    require_relative 'event_logs/tracking'
+
+    THREAD_VAR_NAME = :bcdd_result_event_logs_tracking
+
+    EnsureResult = ->(result) do
+      return result if result.is_a?(::BCDD::Result)
+
+      raise Error::UnexpectedOutcome.build(outcome: result, origin: :event_logs)
+    end
+
+    def self.tracking
+      Thread.current[THREAD_VAR_NAME] ||= Tracking.instance
+    end
+  end
+
+  def self.event_logs(name: nil, desc: nil, &block)
+    EventLogs.tracking.exec(name, desc, &block)
+  end
+end

data/lib/bcdd/result/failure.rb

@@ -2,9 +2,7 @@
 
 class BCDD::Result
   class Failure < self
-    require_relative 'failure/methods'
-
-    include Methods
+    include ::BCDD::Failure
   end
 
   def self.Failure(type, value = nil)

data/lib/bcdd/result/success.rb

@@ -2,9 +2,7 @@
 
 class BCDD::Result
   class Success < self
-    require_relative 'success/methods'
-
-    include Methods
+    include ::BCDD::Success
   end
 
   def self.Success(type, value = nil)

data/lib/bcdd/result/version.rb

@@ -2,6 +2,6 @@
 
 module BCDD
   class Result
-    VERSION = '0.13.0'
+    VERSION = '1.0.0'
   end
 end

data/lib/bcdd/result.rb

@@ -1,197 +1,29 @@
 # frozen_string_literal: true
 
 require 'set'
-require 'singleton'
 
-require_relative 'result/version'
-require_relative 'result/error'
-require_relative 'result/ignored_types'
-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(freeze: true)
-    yield(config)
-
-    freeze and 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 = kind == :failure || (terminal && !IgnoredTypes.include?(type))
-    @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) 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) 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)
+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