trace_viz 1.0.0 → 1.0.1

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

@@ -3,8 +3,10 @@
 module TraceViz
   module Renderers
     class BaseRenderer
-      def initialize(data, context:)
-        @data = data
+      NodeLine = Struct.new(:data, :line)
+
+      def initialize(collector, context)
+        @collector = collector
         @context = context
       end
 
@@ -12,13 +14,14 @@ module TraceViz
         to_lines.map { |line| line[:line] }.join("\n")
       end
 
+      # [ { line: 'line1' }, { line: 'line2' } ]
       def to_lines
         []
       end
 
       private
 
-      attr_reader :data, :context
+      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

@@ -3,11 +3,10 @@
 module TraceViz
   module Renderers
     class RenderContext
-      attr_reader :formatter_factory, :group_keys
+      attr_reader :formatter_factory
 
-      def initialize(formatter_factory:, group_keys: [])
+      def initialize(formatter_factory:)
         @formatter_factory = formatter_factory
-        @group_keys = group_keys
       end
 
       def fetch_formatter(key)

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

@@ -2,6 +2,7 @@
 
 require_relative "verbose_renderer"
 require_relative "summary_renderer"
+require_relative "diagram/sequence_renderer"
 
 module TraceViz
   module Renderers
@@ -9,32 +10,19 @@ module TraceViz
       RENDERERS = {
         verbose: VerboseRenderer,
         summary: SummaryRenderer,
+        sequence_diagram: Diagram::SequenceRenderer,
       }.freeze
 
-      class << self
-        def build(mode, collector, context:)
-          renderer_class = fetch_renderer_class(mode)
-          renderer_class.new(determine_input(mode, collector), context: context)
-        end
-
-        private
+      def initialize(collector, context)
+        @collector = collector
+        @context = context
+      end
 
-        def fetch_renderer_class(mode)
-          RENDERERS.fetch(mode) do
-            raise ArgumentError, "Unknown mode: #{mode}. Valid modes are: #{RENDERERS.keys.join(", ")}"
-          end
-        end
+      def build(key)
+        renderer_class = RENDERERS[key]
+        raise ArgumentError, "Invalid renderer key: #{key}" unless renderer_class
 
-        def determine_input(mode, collector)
-          case mode
-          when :verbose
-            collector.collection
-          when :summary
-            collector.hierarchy.root
-          else
-            raise ArgumentError, "Invalid mode for input determination: #{mode}"
-          end
-        end
+        renderer_class.new(@collector, @context)
       end
     end
   end

data/lib/trace_viz/renderers/summary_renderer.rb

@@ -1,21 +1,33 @@
 # frozen_string_literal: true
 
 require_relative "base_renderer"
-require_relative "summary/node_processor"
+require "trace_viz/transformers/summary_transformer"
 
 module TraceViz
   module Renderers
     class SummaryRenderer < BaseRenderer
       def to_lines
-        return [] unless valid_children?(data)
-
-        NodeProcessor.new(data.children, context).process
+        render_nodes(data.children)
       end
 
       private
 
-      def valid_children?(node)
-        node.respond_to?(:children) && node.children.any?
+      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

data/lib/trace_viz/renderers/verbose_renderer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "base_renderer"
-require "trace_viz/formatters/log/formatter_factory"
 
 module TraceViz
   module Renderers
@@ -12,17 +11,18 @@ module TraceViz
 
       private
 
+      def data
+        collector.collection
+      end
+
       def traverse_data(data)
         data.map do |trace_data|
-          {
-            line: format_for(trace_data),
-            trace_data: trace_data,
-          }
+          NodeLine.new(trace_data, format_for(trace_data))
         end
       end
 
       def format_for(trace_data)
-        context.fetch_formatter(trace_data.event).call(trace_data)
+        context.fetch_formatter(trace_data.key).call(trace_data)
       end
     end
   end

data/lib/trace_viz/shared/renderer_helper.rb

@@ -1,27 +1,8 @@
 # frozen_string_literal: true
 
-require "trace_viz/renderers/renderer_factory"
-require "trace_viz/renderers/render_context"
-require "trace_viz/formatters/export/formatter_factory"
-require "trace_viz/formatters/log/formatter_factory"
-
 module TraceViz
   module Shared
     module RendererHelper
-      def build_renderer(collector, formatter_factory)
-        raise ArgumentError, "Collector cannot be nil" unless collector
-        raise ArgumentError, "FormatterFactory cannot be nil" unless formatter_factory
-
-        mode = fetch_config(collector, :mode)
-        group_keys = fetch_config(collector, :group_keys)
-
-        context = Renderers::RenderContext.new(
-          formatter_factory: formatter_factory,
-          group_keys: group_keys,
-        )
-        Renderers::RendererFactory.build(mode, collector, context: context)
-      end
-
       def process_lines(lines, &block)
         return [] unless lines.is_a?(Array)
 
@@ -33,13 +14,11 @@ module TraceViz
 
       private
 
-      def fetch_config(collector, key)
-        collector.config.general[key]
-      end
-
       def validate_line_structure!(line)
-        raise ArgumentError, "Line must be a Hash" unless line.is_a?(Hash)
-        raise KeyError, "Line must include a :line key" unless line.key?(: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

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

@@ -15,6 +15,13 @@ module TraceViz
         record_timestamp
       end
 
+      #
+      # Represents trace data type code
+      #
+      def key
+        :base
+      end
+
       def event
         raise NotImplementedError
       end

data/lib/trace_viz/trace_data/node.rb

@@ -15,9 +15,15 @@ module TraceViz
         @children = []
       end
 
-      def add_child(child)
-        child.parent = self
-        @children << child
+      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

data/lib/trace_viz/trace_data/root_node.rb

@@ -12,6 +12,10 @@ module TraceViz
         @parent = nil
       end
 
+      def root?
+        true
+      end
+
       def parent=(_parent)
         raise NoMethodError, "RootNode cannot have a parent"
       end

data/lib/trace_viz/trace_data/summary_node.rb

@@ -27,7 +27,11 @@ module TraceViz
         add_children(representative_node.children)
       end
 
-      def average_duration
+      def key
+        :summary_group
+      end
+
+      def duration
         return 0 if count.zero?
 
         total_duration / count
@@ -36,14 +40,6 @@ module TraceViz
       def total_duration
         children.map(&:duration).sum
       end
-
-      private
-
-      def add_children(nodes)
-        nodes.each do |node|
-          add_child(node)
-        end
-      end
     end
   end
 end

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

@@ -26,6 +26,10 @@ module TraceViz
           assign_ids
         end
 
+        def key
+          event
+        end
+
         def duration
           0
         end

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

@@ -17,6 +17,10 @@ module TraceViz
           populate_params
         end
 
+        def result
+          method_return&.result
+        end
+
         def link(method_return)
           @method_return = method_return
         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