trace_viz 0.0.2 → 1.0.0

data/lib/trace_viz/trace_data/trace_point/base.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "../base"
+require "trace_viz/traits"
+require_relative "../node"
 
 module TraceViz
   module TraceData
     module TracePoint
-      class Base < TraceData::Base
+      class Base < TraceData::Node
+        include Traits::Identifiable
+
         attr_reader :trace_point,
-          :id,
-          :action_id,
+          :memory_id,
           :event,
           :klass,
           :action,
@@ -19,18 +21,28 @@ module TraceViz
           super()
 
           @trace_point = trace_point
-
-          populate_trace_attributes
+          populate_attributes
+          assign_memory_id
           assign_ids
         end
 
         def duration
-          # TODO: Implement duration calculation
+          0
+        end
+
+        def to_h
+          super.merge(
+            {
+              id: id,
+              action_id: action_id,
+              memory_id: memory_id,
+            },
+          )
         end
 
         private
 
-        def populate_trace_attributes
+        def populate_attributes
           @event = trace_point.event
           @klass = trace_point.defined_class
           @action = trace_point.callee_id
@@ -38,29 +50,8 @@ module TraceViz
           @line_number = trace_point.lineno
         end
 
-        def assign_ids
-          @id = generate_unique_id
-          @action_id = generate_action_id
-        end
-
-        def memory_id
-          trace_point.self.object_id
-        end
-
-        def generate_unique_id
-          [
-            memory_id,
-            action,
-            path,
-            line_number,
-          ].join("_")
-        end
-
-        def generate_action_id
-          [
-            memory_id,
-            action,
-          ].join("_")
+        def assign_memory_id
+          @memory_id = trace_point.self.object_id
         end
       end
     end

data/lib/trace_viz/trace_data/trace_point/method_call.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
+require "trace_viz/helpers/trace_point/param_helper"
 require_relative "base"
 
 module TraceViz
   module TraceData
     module TracePoint
       class MethodCall < Base
-        attr_reader :params
+        include Helpers::TracePoint::ParamHelper
+
+        attr_reader :params, :method_return
 
         def initialize(trace_point)
           super(trace_point)
@@ -14,27 +17,29 @@ module TraceViz
           populate_params
         end
 
-        private
-
-        def populate_params
-          @params = extract_params(trace_point.binding)
+        def link(method_return)
+          @method_return = method_return
         end
 
-        def extract_params(binding)
-          method = binding.eval("method(:#{action})")
-          method.parameters.each_with_object({}) do |(_, name), hash|
-            next unless name
-            next if name.to_s.include?("*") # Skip invalid or special variable names
+        def duration
+          return 0 unless method_return
 
-            value = safe_local_variable_get(binding, name)
-            hash[name] = value
-          end
+          method_return.timestamp - timestamp
         end
 
-        def safe_local_variable_get(binding, name)
-          binding.local_variable_defined?(name) ? binding.local_variable_get(name) : nil
-        rescue NameError
-          nil
+        def to_h
+          super.merge(
+            {
+              params: params,
+              method_return_id: method_return&.id,
+            },
+          )
+        end
+
+        private
+
+        def populate_params
+          @params = extract_params(trace_point.binding, action)
         end
       end
     end

data/lib/trace_viz/trace_data/trace_point/method_return.rb

@@ -6,7 +6,7 @@ module TraceViz
   module TraceData
     module TracePoint
       class MethodReturn < Base
-        attr_reader :result
+        attr_reader :result, :method_call
 
         def initialize(trace_point)
           super(trace_point)
@@ -14,6 +14,26 @@ module TraceViz
           populate_result
         end
 
+        def link(method_call)
+          @method_call = method_call
+          method_call.link(self)
+        end
+
+        def duration
+          return 0 unless method_call
+
+          timestamp - method_call.timestamp
+        end
+
+        def to_h
+          super.merge(
+            {
+              result: result,
+              method_call_id: method_call&.id,
+            },
+          )
+        end
+
         private
 
         def populate_result

data/lib/trace_viz/traits/depth_trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Traits
+    module DepthTrackable
+      attr_reader :depth
+
+      def assign_depth(depth)
+        @depth = depth
+      end
+    end
+  end
+end

data/lib/trace_viz/traits/identifiable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/id_generator"
+
+module TraceViz
+  module Traits
+    module Identifiable
+      attr_reader :id, :action_id
+
+      def assign_ids
+        @id = Utils::IDGenerator.generate_unique_id(
+          memory_id: memory_id,
+          action: action,
+          path: path,
+          line_number: line_number,
+        )
+
+        @action_id = Utils::IDGenerator.generate_action_id(
+          memory_id: memory_id,
+          action: action,
+        )
+      end
+    end
+  end
+end

data/lib/trace_viz/traits/time_trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Traits
+    module TimeTrackable
+      attr_reader :timestamp
+
+      def record_timestamp
+        @timestamp = Time.now
+      end
+    end
+  end
+end

data/lib/trace_viz/traits.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "traits/time_trackable"
+require_relative "traits/depth_trackable"
+require_relative "traits/identifiable"
+
+module TraceViz
+  module Traits
+  end
+end

data/lib/trace_viz/utils/colorize.rb

@@ -4,17 +4,17 @@ module TraceViz
   module Utils
     module Colorize
       class << self
-        def colorize(text, *styles)
-          return text if text.nil? || styles.empty?
+        def colorize(text, *colors)
+          return text if text.nil? || colors.empty?
 
-          "#{build_color_sequence(styles)}#{text}#{Defaults.colors[:reset]}"
+          "#{build_color_sequence(colors)}#{text}#{Defaults::Colors.fetch(:default)}"
         end
 
         private
 
-        def build_color_sequence(styles)
-          styles
-            .map { |style| Defaults.colors[style] }
+        def build_color_sequence(colors)
+          colors
+            .map { |color| Defaults::Colors.fetch(color) }
             .compact
             .join
         end

data/lib/trace_viz/utils/format_utils/key_value_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module FormatUtils
+      class KeyValueFormatter
+        DEFAULT_MODE = :name_and_value
+
+        def initialize(mode: DEFAULT_MODE)
+          @mode = mode
+          @formatter = build_formatter
+        end
+
+        def call(data)
+          validate_input(data)
+          data.map { |key, value| @formatter.call(key, value) }.join(", ")
+        end
+
+        private
+
+        def validate_input(data)
+          unless data.is_a?(Hash)
+            raise ArgumentError, "Expected a Hash for key-value formatting, got #{data.class}"
+          end
+        end
+
+        def build_formatter
+          {
+            name_and_value: ->(key, value) { "#{key}: #{value}" },
+            name_only: ->(key, _) { key.to_s },
+            value_only: ->(_, value) { value.to_s },
+          }.fetch(@mode) { raise ArgumentError, "Invalid mode: #{@mode}" }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/format_utils/value_truncator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module FormatUtils
+      class ValueTruncator
+        DEFAULT_LENGTH = -1
+        VALID_DIRECTIONS = [:start, :end].freeze
+
+        def initialize(length: DEFAULT_LENGTH, direction: :end)
+          @length = length
+          @direction = validate_direction(direction)
+        end
+
+        def truncate(value)
+          return value unless valid_length?
+
+          case value
+          when String then truncate_string(value)
+          when Array then truncate_array(value)
+          when Hash then truncate_hash(value)
+          else truncate_generic(value)
+          end
+        end
+
+        private
+
+        attr_reader :length, :direction
+
+        def validate_direction(direction)
+          return direction if VALID_DIRECTIONS.include?(direction)
+
+          raise ArgumentError, "Invalid direction: #{direction}. Valid options are :start or :end."
+        end
+
+        def valid_length?
+          length.is_a?(Integer) && length.positive?
+        end
+
+        def truncate_string(string)
+          return string if string.length <= length
+
+          case direction
+          when :start then "...#{string[-length..]}"
+          when :end then "#{string[0, length]}..."
+          end
+        end
+
+        def truncate_array(array)
+          truncated = array.take(length)
+          truncated << "..." if array.size > length
+          truncated
+        end
+
+        def truncate_hash(hash)
+          keys = hash.keys.take(length)
+          truncated_pairs = keys.map { |key| "#{key}: #{truncate(hash[key])}" }
+          truncated_pairs << "..." if hash.size > length
+          "{#{truncated_pairs.join(", ")}}"
+        end
+
+        def truncate_generic(object)
+          object_str = object.inspect
+          return object_str if object_str.length <= length
+
+          case direction
+          when :start then "#{object.class}(...#{object_str[-length..]})"
+          when :end then "#{object.class}(#{object_str[0, length]}...)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/format_utils.rb

@@ -1,65 +1,22 @@
 # frozen_string_literal: true
 
+require_relative "format_utils/key_value_formatter"
+require_relative "format_utils/value_truncator"
+
 module TraceViz
   module Utils
     module FormatUtils
       class << self
-        # Formats a hash or array of key-value pairs based on the specified mode
+        # Formats key-value pairs based on the provided mode
         def format_key_value_pairs(data, mode)
-          data.map { |key, value| display_mode(mode).call(key, value) }.join(", ")
-        end
-
-        # Determines how key-value pairs are displayed based on the mode
-        def display_mode(mode)
-          {
-            name_and_value: ->(name, value) { "#{name}: #{value}" },
-            name_only: ->(name, _) { name.to_s },
-            value_only: ->(_, value) { value },
-          }.fetch(mode)
-        end
-
-        # Truncates a string or array to the specified length
-        def truncate_value(value, length)
-          return value unless length.is_a?(Integer) && length.positive?
-
-          case value
-          when String
-            truncate_string(value, length)
-          when Array
-            truncate_array(value, length)
-          when Hash
-            truncate_hash(value, length)
-          else
-            truncate_object(value, length)
-          end
-        end
-
-        private
-
-        def truncate_string(string, length)
-          string.length > length ? "#{string[0, length]}..." : string
-        end
-
-        def truncate_array(array, length)
-          truncated_array = array.take(length)
-          truncated_array << "..." if array.size > length
-          truncated_array
-        end
-
-        def truncate_hash(hash, length)
-          keys = hash.keys.take(length)
-          truncated_pairs = keys.map { |key| "#{key}: #{truncate_value(hash[key], length)}" }
-          truncated_pairs << "..." if hash.size > length
-          "{#{truncated_pairs.join(", ")}}"
+          formatter = KeyValueFormatter.new(mode: mode)
+          formatter.call(data)
         end
 
-        def truncate_object(object, length)
-          object_string = object.inspect
-          if object.is_a?(Hash) || object.is_a?(Array)
-            truncate_value(object, length)
-          else
-            object_string.length > length ? "#{object.class}(#{object_string[0, length]}...)" : object_string
-          end
+        # Truncates a value to the specified length
+        def truncate_value(value, length, direction: :end)
+          truncator = ValueTruncator.new(length: length, direction: direction)
+          truncator.truncate(value)
         end
       end
     end

data/lib/trace_viz/utils/id_generator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    class IDGenerator
+      ID_DELIMITER = "|"
+      COMPONENT_DELIMITER = ":"
+
+      class << self
+        def generate_unique_id(memory_id:, action:, path:, line_number:)
+          join_with_delimiters(
+            memory: memory_id,
+            action: action,
+            path: path,
+            line: line_number,
+          )
+        end
+
+        def generate_action_id(memory_id:, action:)
+          join_with_delimiters(
+            memory: memory_id,
+            action: action,
+          )
+        end
+
+        private
+
+        def join_with_delimiters(**components)
+          components.map { |key, value| "#{key}#{COMPONENT_DELIMITER}#{value}" }
+            .join(ID_DELIMITER)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TraceViz
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/sig/adapters/base_adapter.rbs

@@ -0,0 +1,11 @@
+module TraceViz
+  module Adapters
+    class BaseAdapter
+      def initialize: () -> void
+      
+      def trace: () -> void
+
+      private attr_reader config: untyped
+    end
+  end
+end

data/sig/adapters/trace_point_adapter.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Adapters
+    class TracePointAdapter < BaseAdapter
+      def initialize: () -> void
+
+      def trace: () { () -> void } -> void
+
+      private attr_reader collector: TraceViz::Collectors::TracePointCollector
+
+      private def exporter: () -> untyped
+    end
+  end
+end

data/sig/collectors/filters/registry.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Collectors
+    module Filters
+      class Registry
+        FILTERS: Hash[Symbol, untyped]
+
+        def self.build: (Array[Symbol | Hash[Symbol, untyped]] filters) -> Array[untyped]
+
+        private def self.fetch_filter_class: (Symbol filter_key) -> untyped
+      end
+    end
+  end
+end

data/sig/collectors/trace_point_collector.rbs

@@ -0,0 +1,17 @@
+module TraceViz
+  module Collectors
+    class TracePointCollector
+      def initialize: () -> void
+
+      private attr_reader action_matcher: TraceViz::Matchers::TracePointActionMatcher
+      private attr_reader within_depth_matcher: TraceViz::Matchers::WithinDepthMatcher
+
+      private def collectible?: (untyped) -> bool
+      private def build_trace: (untyped) -> untyped
+      private def update_trace_depth: (untyped) -> void
+      private def match_action?: (untyped) -> bool
+      private def within_depth?: () -> bool
+      private def depth_manager: () -> TraceViz::Collectors::DepthManager
+    end
+  end
+end

data/sig/config/copier.rbs

@@ -0,0 +1,15 @@
+module TraceViz
+  module Config
+    class Copier
+      @origin_configuration: untyped
+      @settings: Hash[Symbol, untyped]
+
+      def initialize: (untyped configuration) -> void
+      def copy: () -> untyped
+
+      private def deep_copy: (untyped value) -> untyped
+      private attr_reader origin_configuration: untyped
+      private attr_reader settings: Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/config/validator.rbs

@@ -0,0 +1,18 @@
+module TraceViz
+  module Config
+    class Validator
+      FILTER_KEYS: Array[Symbol]
+
+      @validations: Hash[Symbol, ^(untyped) -> void]
+
+      def initialize: () -> void
+      def validate: (Symbol group, Symbol value) -> void
+
+      private def validate_params: (Hash[Symbol, untyped] value) -> void
+      private def validate_result: (Hash[Symbol, untyped] value) -> void
+      private def validate_source_location: (Hash[Symbol, untyped] value) -> void
+      private def validate_filters: (Array[untyped] filters) -> void
+      private def validate_export: (Hash[Symbol, untyped] value) -> void
+    end
+  end
+end

data/sig/configuration.rbs

@@ -0,0 +1,22 @@
+module TraceViz
+  class Configuration
+    @logger: TraceViz::Logger
+    @validator: TraceViz::Config::Validator
+    @settings: Hash[Symbol, untyped]
+
+    attr_reader logger: TraceViz::Logger
+    attr_reader settings: Hash[Symbol, untyped]
+
+    def initialize: () -> void
+    def []: (Symbol key) -> untyped
+    def update: (Symbol group, untyped values) -> void
+    def reset_defaults: () -> void
+    def dup: () -> TraceViz::Config::Copier
+
+    private def define_dynamic_accessors: () -> void
+  end
+
+  def self.configuration: () -> TraceViz::Configuration
+  def self.configure: () { (TraceViz::Configuration) -> void } -> void
+  def self.logger: () -> TraceViz::Logger
+end

data/sig/context/base_context.rbs

@@ -0,0 +1,9 @@
+module TraceViz
+  module Context
+    class BaseContext
+      attr_reader options: Hash[Symbol, untyped]
+
+      def initialize: (options: Hash[Symbol, untyped]) -> void
+    end
+  end
+end

data/sig/context/config_context.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Context
+    class ConfigContext
+      attr_reader configuration: untyped
+
+      def initialize: (options: Hash[Symbol, untyped]) -> void
+
+      def temp_configuration: () -> untyped
+
+      def apply_options: (Hash[Symbol, untyped]) -> untyped
+    end
+  end
+end

data/sig/context/manager.rbs

@@ -0,0 +1,10 @@
+module TraceViz
+  module Context
+    class Manager
+      def self.enter_contexts: (Hash[Symbol, untyped] contexts) -> void
+      def self.exit_contexts: (*Symbol keys) -> void
+      def self.with_contexts: (?Hash[Symbol, untyped] contexts) { () -> void } -> void
+      def self.fetch_context: (Symbol key) -> untyped
+    end
+  end
+end

data/sig/context/map.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Context
+    class Map
+      @context_map: Hash[Symbol, untyped]
+
+      def initialize: () -> void
+      def replace: (Hash[Symbol, untyped] new_map) -> void
+      def fetch: (Symbol key) -> untyped
+      def remove: (*Symbol keys) -> void
+      def reset: () -> void
+    end
+  end
+end

data/sig/context.rbs

@@ -0,0 +1,5 @@
+module TraceViz
+  module Context
+    def self.for: (Symbol key) -> TraceViz::Context::Manager
+  end
+end