tp_tree 0.1.0

data/lib/tp_tree/method_filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module TPTree
+  # MethodFilter handles filtering and excluding method calls based on various criteria
+  class MethodFilter
+    def initialize(filter: nil, exclude: nil)
+      @filter_matchers = build_matchers(filter) if filter
+      @exclude_matchers = build_matchers(exclude) if exclude
+    end
+
+    def should_include?(method_name, defined_class, tp)
+      # If we have filters, method must match at least one filter
+      if @filter_matchers && !@filter_matchers.empty?
+        return false unless matches_any?(@filter_matchers, method_name, defined_class, tp)
+      end
+
+      # If we have excludes, method must not match any exclude
+      if @exclude_matchers && !@exclude_matchers.empty?
+        return false if matches_any?(@exclude_matchers, method_name, defined_class, tp)
+      end
+
+      true
+    end
+
+    private
+
+    def build_matchers(criteria)
+      case criteria
+      when Array
+        criteria.map { |item| build_single_matcher(item) }
+      else
+        [build_single_matcher(criteria)]
+      end
+    end
+
+    def build_single_matcher(criterion)
+      case criterion
+      when String
+        ->(method_name, defined_class, tp) { method_name.to_s == criterion }
+      when Regexp
+        ->(method_name, defined_class, tp) { criterion.match?(method_name.to_s) }
+      when Proc
+        criterion
+      else
+        raise ArgumentError, "Filter/exclude criteria must be String, Regexp, Array, or Proc"
+      end
+    end
+
+    def matches_any?(matchers, method_name, defined_class, tp)
+      matchers.any? { |matcher| matcher.call(method_name, defined_class, tp) }
+    end
+  end
+end

data/lib/tp_tree/presenters/tree_node_presenter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../formatters/ansi_formatter'
+
+module TPTree
+  module Presenters
+    # TreeNodePresenter handles the formatting and display logic for TreeNode objects
+    class TreeNodePresenter
+      def initialize(tree_node, formatter: nil)
+        @tree_node = tree_node
+        @formatter = formatter || Formatters::AnsiFormatter.new
+      end
+
+      def to_s
+        prefix = build_prefix
+        color = @formatter.color_for_depth(@tree_node.depth)
+        colored_method_name = @formatter.colorize(@tree_node.method_name, color)
+        timing_info = @formatter.format_timing(@tree_node.duration)
+
+        case @tree_node.event
+        when :call
+          "#{prefix}#{colored_method_name}(#{@formatter.format_parameters(@tree_node.parameters)})#{timing_info}"
+        when :return
+          "#{prefix}#{@formatter.format_return_value(@tree_node.return_value)}#{timing_info}"
+        when :call_return
+          "#{prefix}#{colored_method_name}(#{@formatter.format_parameters(@tree_node.parameters)}) → #{@formatter.format_return_value(@tree_node.return_value)}#{timing_info}"
+        end
+      end
+
+      def to_parts
+        prefix_parts = build_prefix_parts
+        color = @formatter.color_for_depth(@tree_node.depth)
+        colored_method_name = @formatter.colorize(@tree_node.method_name, color)
+        timing_info = @formatter.format_timing(@tree_node.duration)
+
+        content = case @tree_node.event
+                  when :call
+                    "#{colored_method_name}(#{@formatter.format_parameters(@tree_node.parameters)})#{timing_info}"
+                  when :return
+                    "#{@formatter.format_return_value(@tree_node.return_value)}#{timing_info}"
+                  when :call_return
+                    "#{colored_method_name}(#{@formatter.format_parameters(@tree_node.parameters)}) → #{@formatter.format_return_value(@tree_node.return_value)}#{timing_info}"
+                  end
+        [prefix_parts, content]
+      end
+
+      private
+
+      def build_prefix_parts
+        parts = []
+        color = @formatter.color_for_depth(@tree_node.depth)
+
+        if @tree_node.event == :return
+          (0...@tree_node.depth).each do |level|
+            parts << ['│  ', @formatter.color_for_depth(level)]
+          end
+          parts << ['└→ ', color]
+          return parts
+        end
+
+        return [] if @tree_node.depth.zero?
+
+        (0...@tree_node.depth).each do |level|
+          parts << ['│  ', @formatter.color_for_depth(level)]
+        end
+        parts
+      end
+
+      def build_prefix
+        build_prefix_parts.map do |text, color|
+          @formatter.colorize(text, color)
+        end.join
+      end
+    end
+  end
+end

data/lib/tp_tree/tree_builder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative 'tree_node'
+require_relative 'call_stack'
+
+module TPTree
+  # TreeBuilder uses TracePoint to build a tree of method calls.
+  class TreeBuilder
+    attr_reader :events
+
+    def initialize(method_filter: nil, &block)
+      @call_stack = CallStack.new
+      @method_filter = method_filter
+      @block = block
+    end
+
+    def events
+      @call_stack.events
+    end
+
+    def build
+      tp = TracePoint.trace(:call, :return) do |tp|
+        next if tp.callee_id == :disable && tp.defined_class == TracePoint
+
+        case tp.event
+        when :call
+          handle_call(tp)
+        when :return
+          handle_return(tp)
+        end
+      end
+
+      @block.call
+      tp.disable
+
+      events
+    end
+
+    private
+
+    def handle_call(tp)
+      # Apply filtering if a method filter is configured
+      if @method_filter && !@method_filter.should_include?(tp.callee_id, tp.defined_class, tp)
+        return
+      end
+
+      param_values = extract_parameters(tp)
+      call_time = Time.now
+
+      @call_stack.start_call(
+        tp.callee_id,
+        param_values,
+        tp.defined_class,
+        tp.path,
+        tp.lineno,
+        call_time
+      )
+    end
+
+        def handle_return(tp)
+      return_time = Time.now
+      call_info = @call_stack.finish_call(tp.callee_id, tp.return_value, return_time)
+
+      # If call_info is nil, the method was filtered out during call
+      return unless call_info
+
+      if call_info[:has_children]
+        # Create separate call and return events
+        call_node = TreeNode.new(
+          :call,
+          call_info[:method_name],
+          call_info[:parameters],
+          nil,
+          call_info[:depth],
+          call_info[:defined_class],
+          call_info[:path],
+          call_info[:lineno],
+          call_info[:start_time],
+          return_time
+        )
+
+        return_node = TreeNode.new(
+          :return,
+          tp.callee_id,
+          nil,
+          tp.return_value,
+          @call_stack.current_depth,
+          tp.defined_class,
+          tp.path,
+          tp.lineno,
+          call_info[:start_time],
+          return_time
+        )
+
+        # Replace placeholder and add return event
+        @call_stack.set_event_at_index(call_info[:event_index], call_node)
+        @call_stack.add_event(return_node)
+      else
+        # Create single call_return event
+        call_return_node = TreeNode.new(
+          :call_return,
+          call_info[:method_name],
+          call_info[:parameters],
+          tp.return_value,
+          call_info[:depth],
+          call_info[:defined_class],
+          call_info[:path],
+          call_info[:lineno],
+          call_info[:start_time],
+          return_time
+        )
+
+        # Replace placeholder
+        @call_stack.set_event_at_index(call_info[:event_index], call_return_node)
+      end
+    end
+
+    def extract_parameters(tp)
+      return tp.parameters.map { |type, name| [type, name, nil] } unless tp.binding
+
+      tp.parameters.map do |param_type, param_name|
+        begin
+          value = case param_type
+                  when :req, :opt, :keyreq, :key
+                    tp.binding.local_variable_get(param_name)
+                  else
+                    nil
+                  end
+          [param_type, param_name, value]
+        rescue NameError
+          [param_type, param_name, nil]
+        end
+      end
+    end
+  end
+end

data/lib/tp_tree/tree_node.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative 'formatter'
+require_relative 'presenters/tree_node_presenter'
+
+module TPTree
+  # TreeNode represents a single event in the method call tree
+  class TreeNode
+    include Formatter
+
+    attr_reader :event, :method_name, :parameters, :return_value, :depth, :defined_class, :path, :lineno, :start_time, :end_time
+
+    def initialize(event, method_name, parameters = nil, return_value = nil, depth = 0, defined_class = nil, path = nil, lineno = nil, start_time = nil, end_time = nil)
+      @event = event
+      @method_name = method_name
+      @parameters = parameters
+      @return_value = return_value
+      @depth = depth
+      @defined_class = defined_class
+      @path = path
+      @lineno = lineno
+      @start_time = start_time
+      @end_time = end_time
+    end
+
+    def duration
+      return nil unless @start_time && @end_time
+      @end_time - @start_time
+    end
+
+    def to_hash
+      {
+        event: @event,
+        method_name: @method_name,
+        parameters: serialize_parameters(@parameters),
+        return_value: serialize_value(@return_value),
+        depth: @depth,
+        defined_class: @defined_class&.to_s,
+        path: @path,
+        lineno: @lineno,
+        start_time: @start_time&.to_f,
+        end_time: @end_time&.to_f,
+        duration: duration
+      }
+    end
+
+    def to_s(formatter: self)
+      # Create appropriate formatter for presenter
+      presenter_formatter = if formatter.respond_to?(:formatter)
+                              formatter.formatter
+                            elsif formatter.respond_to?(:colorize)
+                              formatter
+                            else
+                              # Fallback to default ANSI formatter
+                              Formatters::AnsiFormatter.new
+                            end
+
+      presenter = Presenters::TreeNodePresenter.new(self, formatter: presenter_formatter)
+      presenter.to_s
+    end
+
+    def to_parts(formatter: self)
+      # Create appropriate formatter for presenter
+      presenter_formatter = if formatter.respond_to?(:formatter)
+                              formatter.formatter
+                            elsif formatter.respond_to?(:colorize)
+                              formatter
+                            else
+                              # Fallback to default ANSI formatter
+                              Formatters::AnsiFormatter.new
+                            end
+
+      presenter = Presenters::TreeNodePresenter.new(self, formatter: presenter_formatter)
+      presenter.to_parts
+    end
+
+    private
+
+    def serialize_parameters(parameters)
+      return nil unless parameters
+      parameters.map { |param_type, param_name, param_value|
+        {
+          type: param_type,
+          name: param_name,
+          value: serialize_value(param_value)
+        }
+      }
+    end
+
+    def serialize_value(value)
+      case value
+      when String, Symbol, NilClass, TrueClass, FalseClass, Numeric
+        value
+      when Array
+        value.map { |v| serialize_value(v) }
+      when Hash
+        value.transform_values { |v| serialize_value(v) }
+      when Proc
+        'Proc'
+      else
+        value.inspect
+      end
+    end
+  end
+end

data/lib/tp_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TPTree
+  VERSION = "0.1.0"
+end

data/lib/tp_tree/xml_formatter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'formatters/xml_formatter'
+
+module TPTree
+  # XMLFormatter provides methods for colorizing and formatting output using XML tags.
+  # This module acts as a compatibility layer for the old XMLFormatter module.
+  module XMLFormatter
+    def self.included(base)
+      base.extend(FormatterMethods)
+      base.include(FormatterMethods)
+    end
+
+    module FormatterMethods
+      def formatter
+        @xml_formatter ||= Formatters::XmlFormatter.new
+      end
+
+      def colorize(text, color)
+        formatter.colorize(text, color)
+      end
+
+      def format_timing(duration)
+        formatter.format_timing(duration)
+      end
+
+      def format_parameters(parameters)
+        formatter.format_parameters(parameters)
+      end
+
+      def format_value(value)
+        formatter.format_value(value)
+      end
+
+      def format_return_value(return_value)
+        formatter.format_return_value(return_value)
+      end
+
+      def color_for_depth(depth)
+        formatter.color_for_depth(depth)
+      end
+    end
+
+    # Expose constants for backward compatibility
+    DEPTH_COLORS = Formatters::BaseFormatter::DEPTH_COLORS
+  end
+end

data/lib/tp_tree.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "tp_tree/version"
+require_relative "tp_tree/tree_builder"
+require_relative "tp_tree/method_filter"
+
+module TPTree
+  class <<self
+    # catch sets up a TracePoint to monitor method calls and returns,
+    # printing them in chronological order with proper tree indentation.
+    #
+    # @param interactive [Boolean] whether to show interactive viewer
+    # @param write_to [String] file path to write JSON output to
+    # @param filter [String, Regexp, Array, Proc] only include methods matching these criteria
+    # @param exclude [String, Regexp, Array, Proc] exclude methods matching these criteria
+    def catch(interactive: false, write_to: nil, filter: nil, exclude: nil, &block)
+      filter_obj = MethodFilter.new(filter: filter, exclude: exclude) if filter || exclude
+      events = TreeBuilder.new(method_filter: filter_obj, &block).build
+
+      if interactive
+        require_relative "tp_tree/interactive_viewer"
+        InteractiveViewer.new(events).show
+      elsif write_to
+        require 'json'
+        require 'time'
+        json_data = {
+          version: TPTree::VERSION,
+          timestamp: Time.now.strftime('%Y-%m-%dT%H:%M:%S%z'),
+          events: events.map(&:to_hash)
+        }
+        File.write(write_to, JSON.pretty_generate(json_data))
+        puts "Trace data written to: #{write_to}"
+      else
+        events.each { |event| puts event }
+      end
+    end
+  end
+end

data/sig/tp_tree.rbs

@@ -0,0 +1,4 @@
+module TpTree
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: tp_tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmytro Koval
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: TPTree provides a simple but powerful tracer for method calls, using
+  TracePoint.
+email:
+- contact@dkoval.pro
+executables:
+- tp_tree
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/interactive_timing_demo.rb
+- examples/semi_empty_nodes_demo.rb
+- examples/timing_demo.rb
+- exe/tp_tree
+- lib/tp_tree.rb
+- lib/tp_tree/call_stack.rb
+- lib/tp_tree/formatter.rb
+- lib/tp_tree/formatters/ansi_formatter.rb
+- lib/tp_tree/formatters/base_formatter.rb
+- lib/tp_tree/formatters/xml_formatter.rb
+- lib/tp_tree/interactive_viewer.rb
+- lib/tp_tree/method_filter.rb
+- lib/tp_tree/presenters/tree_node_presenter.rb
+- lib/tp_tree/tree_builder.rb
+- lib/tp_tree/tree_node.rb
+- lib/tp_tree/version.rb
+- lib/tp_tree/xml_formatter.rb
+- sig/tp_tree.rbs
+homepage: https://github.com/dmk/tp_tree
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/dmk/tp_tree
+  source_code_uri: https://github.com/dmk/tp_tree
+  changelog_uri: https://github.com/dmk/tp_tree/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A simple tracer for method calls.
+test_files: []