trace_viz 0.0.2 → 1.0.1

data/lib/trace_viz/managers/diagram/participant_manager.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Managers
+    module Diagram
+      class ParticipantsManager
+        def initialize(participants)
+          @participants_map = build_participants_map(participants)
+        end
+
+        def find(name)
+          @participants_map[name.to_s]
+        end
+
+        private
+
+        def build_participants_map(participants)
+          participants.each_with_object({}) { |participant, memo| memo[participant.name] = participant }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/models/box.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Models
+    class Box
+      attr_reader :participants, :color, :description
+
+      def initialize(color:, description:)
+        @color = color
+        @description = description
+        @participants = []
+      end
+
+      def add_participant(participant)
+        @participants << participant
+      end
+    end
+  end
+end

data/lib/trace_viz/models/diagram.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Models
+    class Diagram
+      attr_reader :boxes, :participants, :messages
+
+      def initialize
+        @boxes = []
+        @participants = []
+        @messages = []
+      end
+
+      def add_box(box)
+        @boxes << box unless @boxes.include?(box)
+      end
+
+      def add_participant(participant)
+        @participants << participant unless @participants.include?(participant)
+      end
+
+      def add_message(message)
+        @messages << message
+      end
+    end
+  end
+end

data/lib/trace_viz/models/message.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Models
+    class Message
+      attr_reader :type, :from, :to, :content
+
+      def initialize(type:, from:, to:, content:)
+        @type = type
+        @from = from
+        @to = to
+        @content = content
+      end
+    end
+  end
+end

data/lib/trace_viz/models/participant.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Models
+    class Participant
+      attr_accessor :name, :alias_name
+
+      def initialize(name:, alias_name: nil)
+        @name = name
+        @alias_name = alias_name
+      end
+
+      def ==(other)
+        name == other.name
+      end
+    end
+  end
+end

data/lib/trace_viz/models.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "models/**/*.rb")].each { |file| require_relative file }
+
+module TraceViz
+  module Models
+  end
+end

data/lib/trace_viz/renderers/base_renderer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Renderers
+    class BaseRenderer
+      NodeLine = Struct.new(:data, :line)
+
+      def initialize(collector, context)
+        @collector = collector
+        @context = context
+      end
+
+      def render
+        to_lines.map { |line| line[:line] }.join("\n")
+      end
+
+      # [ { line: 'line1' }, { line: 'line2' } ]
+      def to_lines
+        []
+      end
+
+      private
+
+      attr_reader :collector, :context
+    end
+  end
+end

data/lib/trace_viz/renderers/diagram/sequence_renderer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../base_renderer"
+require "trace_viz/builders/diagram/sequence_builder"
+require "trace_viz/syntax/mermaid/sequence_syntax"
+
+module TraceViz
+  module Renderers
+    module Diagram
+      class SequenceRenderer < BaseRenderer
+        def initialize(collector, context)
+          super(collector, context)
+
+          @builder = Builders::Diagram::SequenceBuilder.new(collector)
+          @syntax = Syntax::Mermaid::SequenceSyntax.new
+          @diagram = builder.build
+        end
+
+        def to_lines
+          [
+            header_line,
+            *render_boxes,
+            *render_messages,
+          ]
+        end
+
+        private
+
+        attr_reader :builder, :diagram, :syntax
+
+        def header_line
+          NodeLine.new(nil, syntax.header)
+        end
+
+        def render_boxes
+          diagram.boxes.flat_map { |box| render_box(box) }
+        end
+
+        def render_messages
+          diagram.messages.map { |message| NodeLine.new(nil, syntax.message(message)) }
+        end
+
+        def render_box(box)
+          [
+            NodeLine.new(nil, syntax.box_start(box)),
+            *render_participants(box),
+            NodeLine.new(nil, syntax.box_end(box)),
+          ]
+        end
+
+        def render_participants(box)
+          box.participants.map do |participant|
+            NodeLine.new(nil, syntax.participant(participant))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/render_context.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Renderers
+    class RenderContext
+      attr_reader :formatter_factory
+
+      def initialize(formatter_factory:)
+        @formatter_factory = formatter_factory
+      end
+
+      def fetch_formatter(key)
+        formatter_factory.fetch_formatter(key)
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/renderer_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "render_context"
+require_relative "renderer_factory"
+
+module TraceViz
+  module Renderers
+    class RendererBuilder
+      class << self
+        def build(collector, key:, formatter_factory:)
+          raise ArgumentError, "Renderer key must be provided" if key.nil?
+
+          render_context = RenderContext.new(formatter_factory: formatter_factory)
+          renderer_factory = RendererFactory.new(collector, render_context)
+          renderer_factory.build(key)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/renderer_factory.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "verbose_renderer"
+require_relative "summary_renderer"
+require_relative "diagram/sequence_renderer"
+
+module TraceViz
+  module Renderers
+    class RendererFactory
+      RENDERERS = {
+        verbose: VerboseRenderer,
+        summary: SummaryRenderer,
+        sequence_diagram: Diagram::SequenceRenderer,
+      }.freeze
+
+      def initialize(collector, context)
+        @collector = collector
+        @context = context
+      end
+
+      def build(key)
+        renderer_class = RENDERERS[key]
+        raise ArgumentError, "Invalid renderer key: #{key}" unless renderer_class
+
+        renderer_class.new(@collector, @context)
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/summary_renderer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base_renderer"
+require "trace_viz/transformers/summary_transformer"
+
+module TraceViz
+  module Renderers
+    class SummaryRenderer < BaseRenderer
+      def to_lines
+        render_nodes(data.children)
+      end
+
+      private
+
+      def data
+        Transformers::SummaryTransformer.new(collector).transform
+      end
+
+      def render_nodes(nodes)
+        nodes.flat_map { |node| render_node(node) }
+      end
+
+      def render_node(node)
+        node_line = NodeLine.new(node.data, format_node(node.data))
+
+        [node_line] + render_nodes(node.children)
+      end
+
+      def format_node(data)
+        context.fetch_formatter(data.key).call(data)
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/verbose_renderer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_renderer"
+
+module TraceViz
+  module Renderers
+    class VerboseRenderer < BaseRenderer
+      def to_lines
+        traverse_data(data)
+      end
+
+      private
+
+      def data
+        collector.collection
+      end
+
+      def traverse_data(data)
+        data.map do |trace_data|
+          NodeLine.new(trace_data, format_for(trace_data))
+        end
+      end
+
+      def format_for(trace_data)
+        context.fetch_formatter(trace_data.key).call(trace_data)
+      end
+    end
+  end
+end

data/lib/trace_viz/shared/renderer_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Shared
+    module RendererHelper
+      def process_lines(lines, &block)
+        return [] unless lines.is_a?(Array)
+
+        lines.map do |line|
+          validate_line_structure!(line)
+          block.call(line)
+        end.compact
+      end
+
+      private
+
+      def validate_line_structure!(line)
+        unless line.respond_to?(:line) && line.respond_to?(:data)
+          raise ArgumentError,
+            "Invalid line structure: #{line.inspect}. Expected an object with :line and :data attributes."
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/shared.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "shared/**/*.rb")].each { |file| require_relative file }
+
+module TraceViz
+  module Shared
+  end
+end

data/lib/trace_viz/syntax/mermaid/sequence_syntax.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers"
+
+module TraceViz
+  module Syntax
+    module Mermaid
+      class SequenceSyntax
+        include Helpers::ConfigHelper
+
+        def header
+          "sequenceDiagram"
+        end
+
+        def box_start(box)
+          "#{indent}box #{sanitize_name(box.color)} #{sanitize_name(box.description)}"
+        end
+
+        def box_end(_box)
+          "#{indent}end"
+        end
+
+        def participant(participant)
+          alias_name = sanitize_name(participant.alias_name)
+          name = sanitize_name(participant.name)
+          "#{indent}participant #{alias_name} as #{name}"
+        end
+
+        def message(message)
+          from = sanitize_name(message.from&.alias_name)
+          to = sanitize_name(message.to&.alias_name)
+          content = sanitize_name(message.content)
+
+          message_syntax(message.type, from, to, content)
+        end
+
+        private
+
+        def message_syntax(type, from, to, content)
+          case type
+          when :call
+            "#{indent}#{from} ->> #{to}: #{content}"
+          when :return
+            "#{indent}#{from} -->> #{to}: #{content}"
+          when :activate
+            "#{indent}activate #{to}"
+          when :deactivate
+            "#{indent}deactivate #{to}"
+          when :loop_start
+            "#{indent}loop #{content}"
+          when :loop_end
+            "#{indent}end"
+          when :note
+            "#{indent}Note over #{to}: #{content}"
+          else
+            raise ArgumentError, "Unsupported message type: #{type}"
+          end
+        end
+
+        def indent
+          " " * fetch_general_config(:tab_size)
+        end
+
+        def sanitize_name(name)
+          return "" if name.nil?
+
+          # Convert Symbols to Strings and handle string sanitization
+          name = name.to_s.dup
+
+          # Handle class name pattern
+          name.sub!(/^#<Class:/, "[Class]")
+          name.sub!(/>$/, "")
+
+          # Replace unconventional method names with readable alternatives
+          name.gsub!("[]=", "set_value")
+          name.gsub!(/<<\z/, "append")
+          name.gsub!("[]", "get_value")
+          name.gsub!(/\A=/, "assign")
+
+          # Escape specific HTML characters in one pass
+          name.gsub!(/[<>:]/) do |char|
+            case char
+            when "<"
+              "&lt;"
+            when ">"
+              "&gt;"
+            # when ":"
+            #   "&#58;"
+            else
+              char
+            end
+          end
+
+          name
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/base.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
-require "trace_viz/context"
+require "trace_viz/helpers"
+require "trace_viz/traits"
 
 module TraceViz
   module TraceData
     class Base
-      attr_reader :config,
-        :timestamp
-      attr_accessor :depth
+      include Helpers::ConfigHelper
+      include Traits::DepthTrackable
+      include Traits::TimeTrackable
 
       def initialize
-        @config = Context.for(:config).configuration
-
-        @depth = 0
+        assign_depth(0)
         record_timestamp
       end
 
-      # Unique ID for each individual event
-      def id
-        raise NotImplementedError
+      #
+      # Represents trace data type code
+      #
+      def key
+        :base
       end
 
-      # Shared ID betweem events for the same method call
-      def action_id
+      def event
         raise NotImplementedError
       end
 
-      def action
+      def klass
         raise NotImplementedError
       end
 
-      def event
+      def action
         raise NotImplementedError
       end
 
@@ -42,14 +42,14 @@ module TraceViz
         raise NotImplementedError
       end
 
-      def klass
-        raise NotImplementedError
-      end
-
-      private
-
-      def record_timestamp
-        @timestamp = Time.now
+      def to_h
+        {
+          event: event,
+          klass: klass,
+          action: action,
+          path: path,
+          line_number: line_number,
+        }
       end
     end
   end

data/lib/trace_viz/trace_data/node.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module TraceViz
+  module TraceData
+    class Node < Base
+      attr_accessor :parent
+      attr_reader :children
+
+      def initialize
+        super()
+
+        @parent = nil
+        @children = []
+      end
+
+      def add_child(node)
+        node.parent = self
+        @children << node
+      end
+
+      def add_children(nodes)
+        nodes.each do |node|
+          add_child(node)
+        end
+      end
+
+      def to_h
+        super.merge(
+          {
+            parent: parent&.to_s,
+            children: children.map(&:to_h),
+          },
+        )
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/root_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class RootNode < Node
+      def initialize
+        super()
+
+        # Explicitly ensure no parent for root
+        @parent = nil
+      end
+
+      def root?
+        true
+      end
+
+      def parent=(_parent)
+        raise NoMethodError, "RootNode cannot have a parent"
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/summary_node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class SummaryNode < Node
+      attr_reader :group, :count, :representative_node, :event, :klass, :action, :path, :params, :result
+
+      def initialize(group:)
+        super()
+
+        @group = group
+        @count = group.size
+
+        @representative_node = group.first
+        @depth = representative_node.depth
+        @event = representative_node.event
+        @klass = representative_node.klass
+        @path = representative_node.path
+        @action = representative_node.action
+
+        # Representative node is the first node in the group belonging to MethodCall
+        @params = representative_node.params
+        @result = representative_node.method_return.result
+
+        add_children(representative_node.children)
+      end
+
+      def key
+        :summary_group
+      end
+
+      def duration
+        return 0 if count.zero?
+
+        total_duration / count
+      end
+
+      def total_duration
+        children.map(&:duration).sum
+      end
+    end
+  end
+end