bcdd-result 0.13.0 → 1.1.0

data/lib/bcdd/result/config/switchers/features.rb

@@ -6,20 +6,20 @@ class BCDD::Result
       OPTIONS = {
         expectations: {
           default: true,
-          affects: %w[BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+          affects: %w[BCDD::Result::Expectations BCDD::Context::Expectations]
         },
-        transitions: {
+        event_logs: {
           default: true,
-          affects: %w[BCDD::Result BCDD::Result::Context BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+          affects: %w[BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations]
         },
         and_then!: {
           default: false,
-          affects: %w[BCDD::Result BCDD::Result::Context BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+          affects: %w[BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations]
         }
       }.transform_values!(&:freeze).freeze
 
       Listener = ->(option_name, _bool) do
-        Thread.current[Transitions::THREAD_VAR_NAME] = nil if option_name == :transitions
+        Thread.current[EventLogs::THREAD_VAR_NAME] = nil if option_name == :event_logs
       end
 
       def self.switcher

data/lib/bcdd/result/config/switchers/pattern_matching.rb

@@ -6,7 +6,7 @@ class BCDD::Result
       OPTIONS = {
         nil_as_valid_value_checking: {
           default: false,
-          affects: %w[BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+          affects: %w[BCDD::Result::Expectations BCDD::Context::Expectations]
         }
       }.transform_values!(&:freeze).freeze
 

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.1.0'
   end
 end