trace_viz 0.0.2 → 1.0.1

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,32 @@ module TraceViz
           super()
 
           @trace_point = trace_point
-
-          populate_trace_attributes
+          populate_attributes
+          assign_memory_id
           assign_ids
         end
 
+        def key
+          event
+        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 +54,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,33 @@ module TraceViz
           populate_params
         end
 
-        private
+        def result
+          method_return&.result
+        end
 
-        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/transformers/base_transformer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers/config_helper"
+
+module TraceViz
+  module Transformers
+    TransformedNode = Struct.new(:data, :children)
+
+    class BaseTransformer
+      include Helpers::ConfigHelper
+
+      def initialize(collector)
+        @collector = collector
+      end
+
+      def transform
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :collector
+
+      def data
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/trace_viz/transformers/summary_transformer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "trace_viz/trace_data/summary_node"
+require_relative "base_transformer"
+
+module TraceViz
+  module Transformers
+    class SummaryTransformer < BaseTransformer
+      def transform
+        return root_node unless valid_children?(root_node)
+
+        TransformedNode.new(
+          root_node,
+          transform_nodes(root_node.children),
+        )
+      end
+
+      private
+
+      def valid_children?(node)
+        node.respond_to?(:children) && node.children.any?
+      end
+
+      def root_node
+        collector.hierarchy.root
+      end
+
+      def transform_nodes(nodes)
+        nodes.group_by { |node| node_key(node) }
+          .map { |_key, group| transform_group(group) }
+      end
+
+      def node_key(node)
+        group_keys.map { |key| fetch_node_attribute(node, key) }
+      end
+
+      def fetch_node_attribute(node, key)
+        node.respond_to?(key) ? node.public_send(key) : nil
+      end
+
+      def transform_group(group)
+        if group.size > 1
+          create_summary_node(group)
+        else
+          create_single_node(group.first)
+        end
+      end
+
+      def create_summary_node(group)
+        summary_node = TraceData::SummaryNode.new(group: group)
+
+        TransformedNode.new(
+          summary_node,
+          transform_nodes(summary_node.children),
+        )
+      end
+
+      def create_single_node(node)
+        TransformedNode.new(
+          node,
+          transform_nodes(node.children),
+        )
+      end
+
+      def group_keys
+        fetch_general_config(:group_keys)
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/alias_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    class AliasGenerator
+      COMPONENT_DELIMITER = "::"
+      ALIAS_DELIMITER = "_"
+
+      class << self
+        #
+        # Generates a unique alias for a given name and ensures it doesn't conflict
+        # with existing aliases.
+        #
+        def generate(name:, assigned_aliases:)
+          raise ArgumentError, "name cannot be nil" if name.nil?
+
+          # Break the name into components and extract initials
+          alias_candidate = extract_initials(name.to_s)
+
+          # Ensure the alias is unique
+          unique_alias = ensure_unique_alias(
+            candidate: alias_candidate,
+            assigned_aliases: assigned_aliases,
+            original_name: name,
+          )
+
+          # Record the alias in the map
+          assigned_aliases[name] = unique_alias
+          unique_alias
+        end
+
+        private
+
+        #
+        # Extracts initials from a namespaced string
+        #
+        def extract_initials(full_name)
+          parts = full_name.split(COMPONENT_DELIMITER)
+          initials = parts.map { |part| part.scan(/[A-Z]/).join }
+          initials.join(ALIAS_DELIMITER)
+        end
+
+        #
+        # Ensures the alias is unique by appending a counter if necessary
+        #
+        def ensure_unique_alias(candidate:, assigned_aliases:, original_name:)
+          unique_alias = candidate
+          counter = 1
+          while assigned_aliases.value?(unique_alias)
+            unique_alias = "#{candidate}#{ALIAS_DELIMITER}#{counter}"
+            counter += 1
+          end
+          unique_alias
+        end
+      end
+    end
+  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/key_value_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module Format
+      module KeyValueFormatter
+        DEFAULT_MODE = :name_and_value
+        VALID_MODES = [:name_and_value, :name_only, :value_only].freeze
+
+        class << self
+          def format_pairs(data, mode: DEFAULT_MODE)
+            validate_input(data)
+            formatter = build_formatter(mode)
+            data.map { |key, value| formatter.call(key, value) }.join(", ")
+          end
+
+          private
+
+          def validate_input(data)
+            raise ArgumentError,
+              "Expected a Hash for data, but received #{data.class}. Please pass a valid Hash." unless data.is_a?(Hash)
+          end
+
+          def build_formatter(mode)
+            unless VALID_MODES.include?(mode)
+              raise ArgumentError, "Invalid mode: #{mode}. Valid modes are: #{VALID_MODES.join(", ")}."
+            end
+
+            case mode
+            when :name_and_value
+              ->(key, value) { "#{key}: #{value}" }
+            when :name_only
+              ->(key, _) { key.to_s }
+            when :value_only
+              ->(_, value) { value.to_s }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module Format
+      module ValueTruncator
+        DEFAULT_LENGTH = -1
+        VALID_DIRECTIONS = [:start, :end].freeze
+
+        class << self
+          def truncate(value, length: DEFAULT_LENGTH, direction: :end, hash_length: DEFAULT_LENGTH)
+            validate_params(length, direction, hash_length)
+
+            # Skip truncation if length is not positive
+            return value unless length.positive?
+
+            opts = {
+              value: value,
+              length: length,
+              direction: direction,
+              hash_length: hash_length,
+            }
+
+            case value
+            when String then truncate_string(opts)
+            when Array then truncate_array(opts)
+            when Hash then truncate_hash(opts)
+            else truncate_object(opts)
+            end
+          end
+
+          private
+
+          def validate_params(length, direction, hash_length)
+            validate_length(length)
+            validate_length(hash_length)
+            validate_direction(direction)
+          end
+
+          def validate_length(val)
+            return if val.is_a?(Integer) && (val.positive? || val == DEFAULT_LENGTH)
+
+            raise ArgumentError, "Invalid length: #{val}. Must be a positive Integer or -1."
+          end
+
+          def validate_direction(direction)
+            return if VALID_DIRECTIONS.include?(direction)
+
+            raise ArgumentError, "Invalid direction: #{direction}. Valid options are :start or :end."
+          end
+
+          def truncate_string(opts)
+            string = opts[:value]
+            length = opts[:length]
+            direction = opts[:direction]
+
+            return string if string.length <= length
+
+            case direction
+            when :start then "...#{string[-length..]}"
+            when :end then "#{string[0, length]}..."
+            end
+          end
+
+          def truncate_array(opts)
+            array = opts[:value]
+            length = opts[:length]
+
+            return array if array.size <= length
+
+            truncated = array.take(length)
+            truncated << "..." if array.size > length
+            truncated
+          end
+
+          def truncate_hash(opts)
+            hash = opts[:value]
+            length = opts[:length]
+            direction = opts[:direction]
+            hash_length = opts[:hash_length]
+
+            truncated_keys = hash.keys.take(length)
+
+            truncated_parts = truncated_keys.map do |key|
+              "#{key}: #{truncate(hash[key], **opts.except(:value))}"
+            end
+
+            truncated_parts << "..." if hash.size > length
+            format_hash(
+              content: truncated_parts.join(", "),
+              direction: direction,
+              hash_length: hash_length,
+            )
+          end
+
+          def format_hash(content:, direction:, hash_length:)
+            # Only truncate the final string if hash_length is positive
+            return "{#{content}}" unless hash_length.positive?
+
+            case direction
+            when :start then "{...#{content[-hash_length..]}}"
+            when :end then "{#{content[0, hash_length]}...}"
+            end
+          end
+
+          def truncate_object(opts)
+            object = opts[:value]
+            length = opts[:length]
+            direction = opts[:direction]
+
+            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
+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/utils.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "utils/**/*.rb")].each { |file| require_relative file }
+
+module TraceViz
+  module Utils
+  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.1"
 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