trace_viz 0.0.2 → 1.0.1

data/lib/trace_viz/defaults/themes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Themes
+      SOLARIZED = {
+        base03: :color_234,
+        base02: :color_235,
+        base01: :color_240,
+        base00: :color_241,
+        base0: :color_244,
+        base1: :color_245,
+        base2: :color_254,
+        base3: :color_230,
+        yellow: :color_136,
+        orange: :color_166,
+        red: :color_160,
+        magenta: :color_125,
+        violet: :color_61,
+        blue: :color_33,
+        cyan: :color_37,
+        green: :color_64,
+      }.freeze
+
+      class << self
+        def solarized
+          SOLARIZED
+        end
+
+        def apply_solarized_theme
+          colors = {
+            default: SOLARIZED[:base0],
+            info: SOLARIZED[:blue],
+            success: SOLARIZED[:green],
+            error: SOLARIZED[:red],
+            warn: SOLARIZED[:yellow],
+            start: SOLARIZED[:blue],
+            processing: SOLARIZED[:base01],
+            finish: SOLARIZED[:magenta],
+            exported: SOLARIZED[:green],
+            skipped: SOLARIZED[:base01],
+            stats: [:bold, :underline, SOLARIZED[:base2]],
+            trace_indent: SOLARIZED[:base03],
+            trace_depth: SOLARIZED[:blue],
+            trace_depth_prefix: [:italic, SOLARIZED[:base02]],
+            trace_depth_open: SOLARIZED[:base02],
+            trace_depth_value: SOLARIZED[:red],
+            trace_depth_close: SOLARIZED[:base03],
+            trace_method_name: SOLARIZED[:cyan],
+            trace_method_class: [:bold, SOLARIZED[:green]],
+            trace_method_sign: SOLARIZED[:violet],
+            trace_method_action: [:bold, SOLARIZED[:blue]],
+            trace_source_location: SOLARIZED[:base01],
+            trace_params_key: SOLARIZED[:orange],
+            trace_params_value: SOLARIZED[:base00],
+            trace_result_prefix: SOLARIZED[:base1],
+            trace_result_value: SOLARIZED[:base3],
+            trace_execution_time: SOLARIZED[:cyan],
+          }
+
+          Defaults.action_colors = colors
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/defaults.rb

@@ -1,138 +1,19 @@
 # frozen_string_literal: true
 
-module TraceViz
-  class Defaults
-    COLORS = {
-      reset: "\e[0m",
-      bold: "\e[1m",
-      dim: "\e[2m",
-      underline: "\e[4m",
-      reverse: "\e[7m",
-      black: "\e[30m",
-      red: "\e[31m",
-      green: "\e[32m",
-      yellow: "\e[33m",
-      blue: "\e[34m",
-      magenta: "\e[35m",
-      cyan: "\e[36m",
-      light_gray: "\e[37m",
-      dark_gray: "\e[90m",
-      light_red: "\e[91m",
-      light_green: "\e[92m",
-      light_yellow: "\e[93m",
-      light_blue: "\e[94m",
-      light_magenta: "\e[95m",
-      light_cyan: "\e[96m",
-      white: "\e[97m",
-      dim_light_gray: "\e[2;37m",
-    }.freeze
-
-    ACTION_EMOJIS = {
-      default: "",
-      info: "ℹ️",
-      success: "✅",
-      error: "❌",
-      warn: "⚠️",
-      start: "🚀",
-      processing: "🔄",
-      finish: "🏁",
-      exported: "📤",
-      skipped: "⏩",
-      stats: "📊",
-    }.freeze
-
-    ACTION_COLORS = {
-      default: :reset,
-      info: :cyan,
-      success: :green,
-      error: :light_red,
-      warn: :yellow,
-      start: :light_cyan,
-      processing: :dim_light_gray,
-      finish: :light_magenta,
-      exported: :light_green,
-      skipped: :dark_gray,
-      stats: :underline,
-    }.freeze
-
-    CONFIG = {
-      general: {
-        tab_size: 2,
-        show_indent: true,
-        show_depth: true,
-        max_display_depth: 3,
-        show_method_name: true,
-      },
-      source_location: {
-        show: false,
-        truncate_length: 100,
-      },
-      params: {
-        show: true,
-        mode: :name_and_value,
-        truncate_values: 50,
-      },
-      result: {
-        show: true,
-        truncate_length: 50,
-      },
-      execution: {
-        show_time: true,
-        show_trace_events: [:call, :return],
-      },
-      filters: [
-        :exclude_internal_call,
-        # :exclude_default_classes,
-        # :exclude_rails_framework,
-        # include_classes: {
-        #   classes: [],
-        # },
-        # exclude_classes: {
-        #   classes: [],
-        # },
-        # include_gems: {
-        #   app_running: true,
-        #   app_path: Dir.pwd,
-        #   gems: [],
-        # },
-        # exclude_gems: {
-        #   gems: [],
-        # },
-      ],
-      export: {
-        enabled: true,
-        path: "tmp",
-        format: :txt,
-        overwrite: false,
-      },
-    }.freeze
+require_relative "defaults/config"
+require_relative "defaults/colors"
+require_relative "defaults/themes"
+require_relative "defaults/actions"
 
-    VALID_PARAM_MODES = [:name_and_value, :name_only, :value_only].freeze
-    VALID_EXPORT_FORMATS = [:txt, :json, :yml].freeze
+module TraceViz
+  module Defaults
+    @action_colors = Actions::COLORS.dup
 
     class << self
-      def colors
-        COLORS
-      end
-
-      def action_colors
-        ACTION_COLORS
-      end
-
-      def action_emojis
-        ACTION_EMOJIS
-      end
-
-      def fetch_defaults
-        CONFIG.dup
-      end
-
-      def valid_param_modes
-        VALID_PARAM_MODES
-      end
+      attr_reader :action_colors
 
-      def valid_export_formats
-        VALID_EXPORT_FORMATS
+      def action_colors=(new_colors)
+        @action_colors.merge!(new_colors)
       end
     end
   end

data/lib/trace_viz/exporters/base_exporter.rb

@@ -1,18 +1,28 @@
 # frozen_string_literal: true
 
 require "fileutils"
-
-require "trace_viz/context"
-require_relative "transformers/text_transformer"
+require "trace_viz/helpers"
+require "trace_viz/shared"
+require "trace_viz/renderers/renderer_builder"
+require "trace_viz/formatters/export/formatter_factory"
 
 module TraceViz
   module Exporters
     class BaseExporter
+      include Helpers::ConfigHelper
+      include Shared::RendererHelper
+
       def initialize(collector)
-        @config = Context.for(:config).configuration
         @export_config = config.export
         @logger = config.logger
-        @data = transform_collector_data(collector)
+
+        @collector = collector
+
+        @renderer = Renderers::RendererBuilder.build(
+          collector,
+          key: renderer_mode,
+          formatter_factory: Formatters::Export::FormatterFactory.new,
+        )
       end
 
       def export
@@ -32,15 +42,18 @@ module TraceViz
 
       private
 
-      attr_reader :config, :export_config, :logger, :data
+      attr_reader :export_config, :logger, :collector, :renderer
 
-      def transform_collector_data(collector)
-        transformer = Transformers::TextTransformer.new(collector)
-        transformer.transform
+      def renderer_mode
+        fetch_general_config(:mode)
       end
 
       def content
-        raise NotImplementedError
+        data.join("\n")
+      end
+
+      def data
+        process_lines(renderer.to_lines) { |line| line[:line] }
       end
 
       def export_enabled?
@@ -70,10 +83,15 @@ module TraceViz
       end
 
       def file_path
-        format = export_config[:format]
-        path = export_config[:path]
+        "#{export_directory}/trace_output#{file_extension}"
+      end
 
-        "#{path}/trace_output.#{format}"
+      def export_directory
+        export_config[:path]
+      end
+
+      def file_extension
+        raise NotImplementedError
       end
 
       def write_file(data)

data/lib/trace_viz/exporters/export_manager.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers"
+require_relative "registry"
+
+module TraceViz
+  module Exporters
+    class ExportManager
+      include Helpers::ConfigHelper
+
+      def export(collector)
+        return unless export_enabled?
+
+        exporter = build_exporter(collector)
+        exporter.export
+      end
+
+      private
+
+      def build_exporter(collector)
+        Registry.build(export_format, collector)
+      end
+
+      def export_format
+        config.export[:format]
+      end
+
+      def export_enabled?
+        config.export[:enabled]
+      end
+    end
+  end
+end

data/lib/trace_viz/exporters/mermaid_exporter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Exporters
+    class MermaidExporter < BaseExporter
+      private
+
+      def renderer_mode
+        :sequence_diagram
+      end
+
+      def file_extension
+        ".mmd"
+      end
+    end
+  end
+end

data/lib/trace_viz/exporters/registry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "text_exporter"
+require_relative "mermaid_exporter"
+
+module TraceViz
+  module Exporters
+    class Registry
+      EXPORTS = {
+        txt: TextExporter,
+        mermaid: MermaidExporter,
+      }
+
+      class << self
+        def build(format, *options)
+          raise ArgumentError unless supported_formats.include?(format)
+
+          EXPORTS[format].new(*options)
+        end
+
+        def supported_formats
+          EXPORTS.keys
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/exporters/text_exporter.rb

@@ -7,8 +7,8 @@ module TraceViz
     class TextExporter < BaseExporter
       private
 
-      def content
-        data.join("\n")
+      def file_extension
+        ".txt"
       end
     end
   end

data/lib/trace_viz/extractors/base_extractor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Extractors
+    class BaseExtractor
+      attr_reader :collector
+
+      def initialize(collector)
+        @collector = collector
+      end
+
+      def extract
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/trace_viz/extractors/diagram/base_extractor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "trace_viz/transformers/summary_transformer"
+require_relative "../base_extractor"
+
+module TraceViz
+  module Extractors
+    module Diagram
+      class BaseExtractor < BaseExtractor
+        private
+
+        def data
+          @data ||= Transformers::SummaryTransformer.new(collector).transform
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/extractors/diagram/box_extractor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base_extractor"
+require_relative "participant_extractor"
+require "trace_viz/models/box"
+
+module TraceViz
+  module Extractors
+    module Diagram
+      class BoxExtractor < BaseExtractor
+        def initialize(collector)
+          super(collector)
+
+          @participants = ParticipantExtractor.new(collector).extract
+        end
+
+        def extract
+          grouped_participants = group_by_namespace(@participants)
+
+          grouped_participants.map do |namespace, participants|
+            box = Models::Box.new(
+              color: random_rgb,
+              description: namespace,
+            )
+
+            participants.each do |participant|
+              box.add_participant(participant)
+            end
+
+            box
+          end
+        end
+
+        private
+
+        def group_by_namespace(participants)
+          participants.group_by { |participant| extract_namespace(participant.name) }
+        end
+
+        def extract_namespace(klass_name)
+          klass_name.split("::").first
+        end
+
+        def random_rgb
+          "rgb(#{rand(200..255)}, #{rand(200..255)}, #{rand(200..255)})"
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/extractors/diagram/message_extractor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "processors/message_processor"
+require_relative "base_extractor"
+
+module TraceViz
+  module Extractors
+    module Diagram
+      class MessageExtractor < BaseExtractor
+        def initialize(collector, participants)
+          super(collector)
+
+          @node_processor = Processors::MessageProcessor.new(participants)
+        end
+
+        def extract
+          root = data
+          root.children.flat_map { |child| @node_processor.process_node(child) }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/extractors/diagram/participant_extractor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/alias_generator"
+require "trace_viz/models/participant"
+require_relative "base_extractor"
+
+module TraceViz
+  module Extractors
+    module Diagram
+      class ParticipantExtractor < BaseExtractor
+        def extract
+          unique_names = data.map(&:klass).uniq
+
+          assigned_aliases = {}
+
+          unique_names.map do |raw_name|
+            alias_name = Utils::AliasGenerator.generate(
+              name: raw_name,
+              assigned_aliases: assigned_aliases,
+            )
+
+            Models::Participant.new(
+              name: raw_name.to_s,
+              alias_name: alias_name,
+            )
+          end
+        end
+
+        private
+
+        def data
+          collector.collection
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/extractors/diagram/processors/message_processor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "trace_viz/formatters/diagram/sequence/message_formatter"
+require "trace_viz/builders/diagram/message_builder"
+
+module TraceViz
+  module Extractors
+    module Diagram
+      module Processors
+        class MessageProcessor
+          def initialize(participants)
+            @formatter = Formatters::Diagram::Sequence::MessageFormatter.new
+            @message_builder = Builders::Diagram::MessageBuilder.new(@formatter, participants)
+          end
+
+          def process_node(node, caller_node = nil)
+            trace = node.data
+            caller_trace = caller_node&.data
+
+            [].tap do |messages|
+              # Handle participant transitions
+              messages << @message_builder.build_call_message(
+                caller_trace,
+                trace,
+              ) if caller_trace
+
+              # Process the current node
+              messages << handle_loop_start(trace)
+              messages << handle_internal_message(trace)
+              messages << handle_note(trace)
+              messages << handle_activation(trace)
+              messages.concat(process_children(node))
+              messages << handle_deactivation(trace)
+              messages << handle_loop_end(trace)
+
+              # Update the current node after processing
+              messages << @message_builder.build_return_message(
+                trace,
+                caller_trace,
+              ) if caller_trace
+            end.compact
+          end
+
+          private
+
+          def handle_loop_start(trace)
+            return unless loop?(trace)
+
+            @message_builder.build_loop_start_message(trace)
+          end
+
+          def handle_internal_message(trace)
+            @message_builder.build_internal_message(trace)
+          end
+
+          def handle_note(trace)
+            @message_builder.build_note(trace)
+          end
+
+          def handle_activation(trace)
+            return unless node_has_children?(trace)
+
+            @message_builder.build_activate_message(trace)
+          end
+
+          def handle_deactivation(trace)
+            return unless node_has_children?(trace)
+
+            @message_builder.build_deactivate_message(trace)
+          end
+
+          def handle_loop_end(trace)
+            return unless loop?(trace)
+
+            @message_builder.build_loop_end_message
+          end
+
+          def process_children(node)
+            node.children.flat_map { |child| process_node(child, node) }
+          end
+
+          def loop?(trace)
+            trace.key == :summary_group
+          end
+
+          def node_has_children?(trace)
+            trace.children.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/base_formatter.rb

@@ -1,42 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "helpers/indent_helper"
-require_relative "helpers/depth_helper"
-require_relative "helpers/time_helper"
-require_relative "helpers/params_helper"
-require_relative "helpers/source_helper"
-require_relative "helpers/result_helper"
-require_relative "helpers/method_details_helper"
+require "trace_viz/helpers"
 
 module TraceViz
   module Formatters
     class BaseFormatter
-      #
-      # General formatting methods for TraceData::Base
-      # These methods are used to format the output of the trace data
-      # based on the configuration settings.
-      #
+      include Helpers::ConfigHelper
 
-      include Helpers::IndentHelper
-      include Helpers::DepthHelper
-      include Helpers::TimeHelper
-      include Helpers::ParamsHelper
-      include Helpers::SourceHelper
-      include Helpers::ResultHelper
-      include Helpers::MethodDetailsHelper
-
-      def initialize(trace_data)
-        @trace_data = trace_data
-        @config = @trace_data.config
-      end
-
-      def format
+      # Format the data to a line
+      def call
         raise NotImplementedError
       end
-
-      private
-
-      attr_reader :trace_data, :config
     end
   end
 end

data/lib/trace_viz/formatters/base_formatter_factory.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Formatters
+    class BaseFormatterFactory
+      def initialize(formatters)
+        @formatters = formatters.freeze
+      end
+
+      def fetch_formatter(key)
+        @formatters.fetch(key) do
+          raise ArgumentError, "Unsupported formatter key: #{key}. Available keys: #{available_keys.join(", ")}"
+        end
+      end
+
+      private
+
+      def available_keys
+        @formatters.keys
+      end
+    end
+  end
+end