bcdd-result 0.12.0 → 1.0.0

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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module BCDD::Result::Transitions
-  class Tracking::Enabled
-    attr_accessor :tree, :records, :root_started_at
-
-    private :tree, :tree=, :records, :records=, :root_started_at, :root_started_at=
-
-    def exec(name, desc)
-      start(name, desc)
-
-      transition_node = tree.current
-
-      result = EnsureResult[yield]
-
-      tree.move_to_root! if transition_node.root?
-
-      finish(result)
-
-      result
-    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, source)
-      type = type_arg.instance_of?(::Method) ? :method : type_arg
-
-      unless tree.frozen?
-        current_and_then = { type: type, arg: arg, source: source }
-        current_and_then[:method_name] = type_arg.name if type == :method
-
-        tree.current.value[1] = current_and_then
-      end
-
-      yield
-    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)
-    end
-
-    def finish(result)
-      node = tree.current
-
-      tree.move_up!
-
-      return unless node.root?
-
-      duration = (now_in_milliseconds - root_started_at)
-
-      metadata = { duration: duration, tree_map: tree.nested_ids }
-
-      result.send(:transitions=, version: Tracking::VERSION, records: records, metadata: metadata)
-
-      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.records = []
-
-      self.tree = Tree.new(name_and_desc, normalizer: TreeNodeValueNormalizer)
-    end
-
-    def track(result, time:)
-      result = result.data.to_h
-
-      root, = tree.root_value
-      parent, = tree.parent_value
-      current, and_then = tree.current_value
-
-      records << { root: root, parent: parent, current: current, result: result, and_then: and_then, time: time }
-    end
-
-    def now_in_milliseconds
-      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class BCDD::Result
-  module Transitions
-    module Tracking
-      require_relative 'tracking/enabled'
-      require_relative 'tracking/disabled'
-
-      EMPTY_ARRAY = [].freeze
-      EMPTY_HASH = {}.freeze
-      EMPTY_TREE = Tree.new(nil).freeze
-      VERSION = 1
-      EMPTY = { version: VERSION, records: EMPTY_ARRAY, metadata: { duration: 0, tree_map: EMPTY_ARRAY } }.freeze
-
-      def self.instance
-        Config.instance.feature.enabled?(:transitions) ? Tracking::Enabled.new : Tracking::Disabled
-      end
-    end
-  end
-end

data/lib/bcdd/result/transitions.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-class BCDD::Result
-  module Transitions
-    require_relative 'transitions/tree'
-    require_relative 'transitions/tracking'
-
-    THREAD_VAR_NAME = :bcdd_result_transitions_tracking
-
-    EnsureResult = ->(result) do
-      return result if result.is_a?(::BCDD::Result)
-
-      raise Error::UnexpectedOutcome.build(outcome: result, origin: :transitions)
-    end
-
-    def self.tracking
-      Thread.current[THREAD_VAR_NAME] ||= Tracking.instance
-    end
-  end
-
-  def self.transitions(name: nil, desc: nil, &block)
-    Transitions.tracking.exec(name, desc, &block)
-  rescue ::Exception => e
-    Transitions.tracking.reset!
-
-    raise e
-  end
-end

data/sig/bcdd/result/transitions.rbs

@@ -1,100 +0,0 @@
-class BCDD::Result
-  module Transitions
-    class Tree
-      class Node
-        attr_reader id: Integer
-        attr_reader value: untyped
-        attr_reader parent: (Node | nil)
-        attr_reader normalizer: ^(Integer, Array[untyped]) -> untyped
-        attr_reader children: Array[Node]
-
-        def initialize: (
-          untyped value,
-          parent: (Node | nil),
-          id: Integer,
-          normalizer: ^(Integer, Array[untyped]) -> untyped
-        ) -> void
-
-        def insert: (untyped, id: Integer) -> Node
-
-        def root?: () -> bool
-        def leaf?: () -> bool
-        def node?: () -> bool
-        def inspect: () -> String
-      end
-
-      attr_reader size: Integer
-      attr_reader root: Node
-      attr_reader current: Node
-
-      def initialize: (untyped, ?normalizer: ^(Integer, Array[untyped]) -> untyped) -> void
-      def root_value: () -> untyped
-      def parent_value: () -> untyped
-      def current_value: () -> untyped
-      def insert: (untyped) -> Node
-      def insert!: (untyped) -> Tree
-      def move_to!: (Node) -> Tree
-      def move_up!: (?Integer level) -> Tree
-      def move_down!: (?Integer level) -> Tree
-      def move_to_root!: () -> Tree
-
-      NestedIds: ^(Node) -> Array[untyped]
-
-      def nested_ids: () -> Array[untyped]
-    end
-
-    module Tracking
-      EMPTY_ARRAY: Array[untyped]
-      EMPTY_HASH: Hash[untyped, untyped]
-      EMPTY_TREE: Transitions::Tree
-      VERSION: Integer
-      EMPTY: Hash[Symbol, untyped]
-
-      class Enabled
-        private attr_accessor tree: Transitions::Tree
-        private attr_accessor records: Array[Hash[Symbol, untyped]]
-        private attr_accessor root_started_at: Integer
-
-        def exec: (String, String) { () -> untyped } -> BCDD::Result
-        def reset!: () -> void
-        def record: (BCDD::Result) -> void
-        def record_and_then: ((untyped), untyped, untyped) { () -> BCDD::Result } -> BCDD::Result
-        def reset_and_then!: () -> void
-
-        private
-
-        def start: (String, String) -> void
-        def finish: (BCDD::Result) -> void
-
-        TreeNodeValueNormalizer: ^(Integer, Array[untyped]) -> untyped
-
-        def root_start: (Array[untyped]) -> void
-
-        def track: (BCDD::Result, time: Time) -> void
-
-        def now_in_milliseconds: () -> Integer
-      end
-
-      module Disabled
-        def self.exec: (String, String) { () -> untyped } -> BCDD::Result
-        def self.reset!: () -> void
-        def self.record: (BCDD::Result) -> void
-        def self.record_and_then: ((untyped), untyped, untyped) { () -> BCDD::Result } -> BCDD::Result
-        def self.reset_and_then!: () -> void
-
-        private
-
-        def self.start: (String, String) -> void
-        def self.finish: (BCDD::Result) -> void
-      end
-
-      def self.instance: () -> (Enabled | singleton(Disabled))
-    end
-
-    THREAD_VAR_NAME: Symbol
-
-    EnsureResult: ^(untyped) -> BCDD::Result
-
-    def self.tracking: () -> (Tracking::Enabled | singleton(Tracking::Disabled))
-  end
-end