bcdd-result 0.12.0 → 1.0.0

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

@@ -5,9 +5,9 @@ class BCDD::Result
     module Addons
       AFFECTS = %w[
         BCDD::Result.mixin
-        BCDD::Result::Context.mixin
+        BCDD::Context.mixin
         BCDD::Result::Expectations.mixin
-        BCDD::Result::Context::Expectations.mixin
+        BCDD::Context::Expectations.mixin
       ].freeze
 
       OPTIONS = {

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

@@ -4,9 +4,7 @@ class BCDD::Result
   class Config
     module ConstantAliases
       MAPPING = {
-        'Result' => { target: ::Object, name: :Result, value: ::BCDD::Result },
-        'Context' => { target: ::Object, name: :Context, value: ::BCDD::Result::Context },
-        'BCDD::Context' => { target: ::BCDD, name: :Context, value: ::BCDD::Result::Context }
+        'Result' => { target: ::Object, name: :Result, value: ::BCDD::Result }
       }.transform_values!(&:freeze).freeze
 
       OPTIONS = MAPPING.to_h do |option_name, mapping|

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,6 +19,10 @@ class BCDD::Result
       @and_then_ = CallableAndThen::Config.new
     end
 
+    def event_logs
+      EventLogs::Config.instance
+    end
+
     def and_then!
       @and_then_
     end
@@ -31,6 +33,7 @@ class BCDD::Result
       constant_alias.freeze
       pattern_matching.freeze
       and_then!.freeze
+      event_logs.freeze
 
       super
     end
@@ -53,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/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/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/event_logs/config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module BCDD::Result::EventLogs
+  class Config
+    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
+
+    @instance = new
+
+    singleton_class.send(:attr_reader, :instance)
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module BCDD::Result::EventLogs
+  module Listener
+    module ClassMethods
+      def around_event_logs?
+        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_event_logs(scope:)
+      yield
+    end
+
+    def around_and_then(scope:, and_then:)
+      yield
+    end
+
+    def on_record(record:); end
+
+    def on_finish(event_logs:); end
+
+    def before_interruption(exception:, event_logs:); end
+  end
+
+  module Listener::Null
+    extend Listener
+
+    def self.new
+      self
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module BCDD::Result::EventLogs
+  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_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_event_logs? == true' if around_event_logs.size > 1
+
+        @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_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_event_logs = instance if listener?(:around_event_logs, instance)
+
+          instance
+        end
+
+        list.one? ? list[0].new : Listeners.send(:new, instances, around_and_then, around_event_logs)
+      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_event_logs_listener
+
+    private :listeners, :around_and_then_listener, :around_event_logs_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_event_logs_listener = around_event_logs_listener || Listener::Null
+    end
+
+    def on_start(scope:)
+      listeners.each { _1.on_start(scope: scope) }
+    end
+
+    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)
+      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(event_logs:)
+      listeners.each { _1.on_finish(event_logs: event_logs) }
+    end
+
+    def before_interruption(exception:, event_logs:)
+      listeners.each { _1.before_interruption(exception: exception, event_logs: event_logs) }
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BCDD::Result::EventLogs
+  module Tracking::Disabled
+    def self.exec(_name, _desc)
+      EnsureResult[yield]
+    end
+
+    def self.record(result); end
+
+    def self.record_and_then(_type, _data)
+      yield
+    end
+  end
+end

data/lib/bcdd/result/event_logs/tracking/enabled.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+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)
+      event_log_node, scope = start(name, desc)
+
+      result = nil
+
+      listener.around_event_logs(scope: scope) do
+        result = EnsureResult[yield]
+      end
+
+      tree.move_to_root! if event_log_node.root?
+
+      finish(result)
+
+      result
+    rescue ::Exception => e
+      err!(e, event_log_node)
+    end
+
+    def err!(exception, event_log_node)
+      if event_log_node.root?
+        listener.before_interruption(exception: exception, event_logs: map_event_logs)
+
+        reset!
+      end
+
+      raise exception
+    end
+
+    def reset!
+      self.tree = Tracking::EMPTY_TREE
+    end
+
+    def record(result)
+      return if tree.frozen?
+
+      track(result, time: ::Time.now.getutc)
+    end
+
+    def record_and_then(type_arg, arg)
+      return yield if tree.frozen?
+
+      type = type_arg.instance_of?(::Method) ? :method : type_arg
+
+      current_and_then = { type: type, arg: arg }
+      current_and_then[:method_name] = type_arg.name if type == :method
+
+      tree.current.value[1] = current_and_then
+
+      scope, and_then = tree.current_value
+
+      result = nil
+
+      listener.around_and_then(scope: scope, and_then: and_then) { result = yield }
+
+      result
+    end
+
+    def reset_and_then!
+      return if tree.frozen?
+
+      tree.current.value[1] = Tracking::EMPTY_HASH
+    end
+
+    private
+
+    def start(name, desc)
+      name_and_desc = [name, desc]
+
+      tree.frozen? ? root_start(name_and_desc) : tree.insert!(name_and_desc)
+
+      scope = tree.current.value[0]
+
+      listener.on_start(scope: scope)
+
+      [tree.current, scope]
+    end
+
+    def finish(result)
+      node = tree.current
+
+      tree.move_up!
+
+      return unless node.root?
+
+      event_logs = map_event_logs
+
+      result.send(:event_logs=, event_logs)
+
+      listener.on_finish(event_logs: event_logs)
+
+      reset!
+    end
+
+    TreeNodeValueNormalizer = ->(id, (nam, des)) { [{ id: id, name: nam, desc: des }, Tracking::EMPTY_HASH] }
+
+    def root_start(name_and_desc)
+      self.root_started_at = now_in_milliseconds
+
+      self.listener = build_listener
+
+      self.records = []
+
+      self.tree = Tree.new(name_and_desc, normalizer: TreeNodeValueNormalizer)
+    end
+
+    def track(result, time:)
+      record = track_record(result, time)
+
+      records << record
+
+      listener.on_record(record: record)
+
+      record
+    end
+
+    def track_record(result, time)
+      result_data = result.data.to_h
+      result_data[:source] = result.send(:source)
+
+      root, = tree.root_value
+      parent, = tree.parent_value
+      current, and_then = tree.current_value
+
+      { root: root, parent: parent, current: current, result: result_data, and_then: and_then, time: time }
+    end
+
+    def now_in_milliseconds
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
+    def map_event_logs
+      duration = (now_in_milliseconds - root_started_at)
+
+      trace_id = Config.instance.trace_id.call
+
+      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
+
+    def build_listener
+      Config.instance.listener.new
+    rescue ::StandardError => e
+      err = "#{e.message} (#{e.class}); Backtrace: #{e.backtrace&.join(', ')}"
+
+      warn("Fallback to #{Listener::Null} because registered listener raised an exception: #{err}")
+
+      Listener::Null.new
+    end
+  end
+end

data/lib/bcdd/result/event_logs/tracking.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  module EventLogs
+    module Tracking
+      require_relative 'tracking/enabled'
+      require_relative 'tracking/disabled'
+
+      VERSION = 1
+
+      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: EMPTY_IDS, trace_id: nil }.freeze
+      }.freeze
+
+      def self.instance
+        ::BCDD::Result::Config.instance.feature.enabled?(:event_logs) ? Tracking::Enabled.new : Tracking::Disabled
+      end
+    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,10 +89,52 @@ 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
+
+      def ids_list
+        ids.flatten
+      end
+
+      IdsMatrix = ->(tree, row, col, memo, previous) do
+        last_row = previous[0]
+
+        tree.each_with_index do |node, index|
+          row = [(index + 1), last_row].max
+
+          id, leaf = node
+
+          memo[id] = previous == [row, col] ? [row, col + 1] : [row, col]
+
+          previous = memo[id]
+
+          IdsMatrix[leaf, row, col + 1, memo, previous]
+        end
+      end
+
+      def ids_matrix
+        current = [0, 0]
+
+        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]
+
+        node.each { |leaf| IdsLevelParent[leaf, id, level + 1, memo] }
+
+        memo
+      end
+
+      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/expectations/mixin.rb

@@ -38,13 +38,13 @@ class BCDD::Result
     module Addons
       module Continue
         private def Continue(value)
-          Success.new(type: :continued, value: value, source: self)
+          _Result.Success(IgnoredTypes::CONTINUE, value)
         end
       end
 
       module Given
         private def Given(value)
-          Success.new(type: :given, value: value, source: self)
+          _Result.Success(IgnoredTypes::GIVEN, value)
         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/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

@@ -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/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.12.0'
+    VERSION = '1.0.0'
   end
 end