tp_tree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41efefad546a256ec0cbd3bf06ed9c7b4d2e60106a6afc661e6866d9de8fadc2
+  data.tar.gz: 1d7f3ac2d2503bd3bfa1d113fe5c12be99e45e4f0fa501841e3173cf67a60426
+SHA512:
+  metadata.gz: 0d44d838641769aa9a3ef4eea3ede06137522ae17493f13fb050e5d0eca02873828da6f671ef76247108f9ca63bd6a41e8805ef50a450fcb5307b9ecdcc23893
+  data.tar.gz: 96abad194832543b77954753543103924c1390b45f682d278e8cd8f3389cf885326cf0acd2f30d523a853c94d7deb64f43802a5d1fd5f69094b589e28ff23b9a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-15
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dmytro Koval
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# TpTree
+
+A Ruby gem for visualizing method call traces with timing information. TPTree uses Ruby's TracePoint to capture method calls and presents them in a beautiful tree format with execution times, parameters, and return values.
+
+## Features
+
+- 🌳 **Tree visualization** of method calls with proper indentation
+- ⏱️ **Timing information** for performance analysis
+- 🎯 **Method filtering** to focus on specific methods or classes
+- 📊 **JSON export** for integration with external tools
+- 🎨 **Colorized output** for better readability
+- 🔧 **Multiple output formats** (ANSI and XML)
+
+## Installation
+
+Install the gem by executing:
+
+```bash
+gem install tp_tree
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'tp_tree'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Basic Usage
+
+Wrap any code block with `TPTree.catch` to trace method calls:
+
+```ruby
+require 'tp_tree'
+
+def slow_method(n)
+  sleep(0.1)
+  fast_method(n)
+end
+
+def fast_method(n)
+  sleep(0.01)
+  n * 2
+end
+
+TPTree.catch do
+  slow_method(5)
+end
+```
+
+Output:
+```
+slow_method(n = 5) [112.0ms]
+│  fast_method(n = 5) → 10 [11.1ms]
+└→ 10 [112.0ms]
+```
+
+### Method Filtering
+
+Filter methods by name, class, or custom criteria:
+
+```ruby
+# Filter by method name (string or regex)
+TPTree.catch(filter: 'slow_method') do
+  # your code
+end
+
+# Filter by multiple criteria
+TPTree.catch(filter: ['method1', /^User/, SomeClass]) do
+  # your code
+end
+
+# Exclude specific methods
+TPTree.catch(exclude: 'fast_method') do
+  # your code
+end
+
+# Custom filtering with block
+TPTree.catch(filter: ->(call_info) { call_info.method_name.start_with?('api_') }) do
+  # your code
+end
+```
+
+### JSON Export
+
+Export trace data for external analysis:
+
+```ruby
+TPTree.catch(json_file: 'trace.json') do
+  # your code
+end
+```
+
+The JSON file contains structured data with timing, parameters, return values, and call hierarchy.
+
+### Advanced Options
+
+```ruby
+TPTree.catch(
+  filter: 'important_method',     # Method filtering
+  exclude: 'noise_method',        # Method exclusion
+  json_file: 'trace.json',        # JSON export
+  interactive: true               # Interactive viewer (if available)
+) do
+  # your code
+end
+```
+
+## Examples
+
+See the `examples/` directory for complete demonstrations:
+
+- `timing_demo.rb` - Basic timing visualization
+- `interactive_timing_demo.rb` - Interactive viewer demo
+- `semi_empty_nodes_demo.rb` - Complex filtering examples
+
+Run them with:
+```bash
+ruby examples/timing_demo.rb
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dmk/tp_tree. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/dmk/tp_tree/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TpTree project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/dmk/tp_tree/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/examples/interactive_timing_demo.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/tp_tree'
+
+def recursive_fibonacci(n)
+  return n if n <= 1
+  sleep(0.001) # Small delay to make timing visible
+  recursive_fibonacci(n - 1) + recursive_fibonacci(n - 2)
+end
+
+def optimized_fibonacci(n)
+  return n if n <= 1
+  sleep(0.001)
+
+  a, b = 0, 1
+  2.upto(n) do
+    sleep(0.0001)
+    a, b = b, a + b
+  end
+  b
+end
+
+puts "=== Interactive Method Timing Demo ==="
+puts "This demo shows method execution times in interactive mode"
+puts "Use arrow keys to navigate, Enter to expand/collapse, 'q' to quit"
+puts "Press any key to start..."
+gets
+
+TPTree.catch(interactive: true) do
+  puts "Computing fibonacci(5) recursively..."
+  recursive_fibonacci(5)
+
+  puts "Computing fibonacci(5) iteratively..."
+  optimized_fibonacci(5)
+end

data/examples/semi_empty_nodes_demo.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/tp_tree'
+
+# Example methods to demonstrate semi-empty nodes
+class Demo
+  def public_method
+    private_helper_method("hello")
+  end
+
+  private
+
+  def private_helper_method(message)
+    internal_processing(message)
+  end
+
+  def internal_processing(data)
+    final_operation(data.upcase)
+  end
+
+  def final_operation(processed_data)
+    "Result: #{processed_data}"
+  end
+end
+
+puts "=== Without filtering (full call tree) ==="
+TPTree.catch do
+  demo = Demo.new
+  result = demo.public_method
+  puts "Final: #{result}"
+end
+
+puts "\n=== With filtering (semi-empty nodes for filtered methods) ==="
+puts "Filtering out private helper methods but keeping them visible"
+TPTree.catch(exclude: [/private_helper_method/, /internal_processing/]) do
+  demo = Demo.new
+  result = demo.public_method
+  puts "Final: #{result}"
+end
+
+puts "\n=== Heavy filtering (multiple methods filtered) ==="
+TPTree.catch(exclude: [/helper/, /processing/, /operation/]) do
+  demo = Demo.new
+  result = demo.public_method
+  puts "Final: #{result}"
+end

data/examples/timing_demo.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/tp_tree'
+
+def slow_method(n)
+  sleep(0.1)
+  fast_method(n)
+end
+
+def fast_method(n)
+  sleep(0.01)
+  n * 2
+end
+
+def complex_calculation(arr)
+  sleep(0.05)
+  arr.map { |x| slow_method(x) }.sum
+end
+
+puts "=== Method Timing Demo ==="
+puts "This demo shows method execution times in the call tree"
+puts
+
+result = TPTree.catch do
+  complex_calculation([1, 2, 3])
+end
+
+puts "\nDemo completed!"

data/exe/tp_tree

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'tp_tree'
+
+if ARGV.empty?
+  puts "Usage: tp_tree [--interactive] <ruby_file>"
+  exit 1
+end
+
+interactive = ARGV.delete('--interactive')
+file = ARGV.first
+
+unless File.exist?(file)
+  puts "Error: File '#{file}' not found"
+  exit 1
+end
+
+code = File.read(file)
+TPTree.catch(interactive: interactive) do
+  eval(code, TOPLEVEL_BINDING, file)
+end

data/lib/tp_tree/call_stack.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module TPTree
+  # CallStack manages the state of method calls during tracing
+  class CallStack
+    def initialize
+      @call_stack = []
+      @call_depth = 0
+      @events = []
+    end
+
+    def start_call(method_name, parameters, defined_class, path, lineno, start_time)
+      call_info = {
+        method_name: method_name,
+        parameters: parameters,
+        depth: @call_depth,
+        event_index: @events.length,
+        defined_class: defined_class,
+        path: path,
+        lineno: lineno,
+        start_time: start_time
+      }
+
+      @call_stack.push(call_info)
+      @events << nil # Placeholder for the actual TreeNode
+      @call_depth += 1
+
+      call_info
+    end
+
+    def finish_call(method_name, return_value, end_time)
+      return nil if @call_stack.empty?
+
+      # Find matching call on stack (handles filtered nested calls)
+      call_info = @call_stack.last
+      return nil unless call_info && call_info[:method_name] == method_name
+
+      @call_depth -= 1
+      @call_stack.pop
+
+      call_info.merge(
+        return_value: return_value,
+        end_time: end_time,
+        has_children: @events.length > call_info[:event_index] + 1
+      )
+    end
+
+    def add_event(event)
+      @events << event
+    end
+
+    def set_event_at_index(index, event)
+      @events[index] = event
+    end
+
+    def events
+      @events.compact
+    end
+
+    def events_array
+      @events
+    end
+
+    def current_depth
+      @call_depth
+    end
+
+    def empty?
+      @call_stack.empty?
+    end
+  end
+end

data/lib/tp_tree/formatter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'formatters/ansi_formatter'
+
+module TPTree
+  # Formatter provides methods for colorizing and formatting output.
+  # This module acts as a compatibility layer for the old Formatter module.
+  module Formatter
+    def self.included(base)
+      base.extend(FormatterMethods)
+      base.include(FormatterMethods)
+    end
+
+    module FormatterMethods
+      def formatter
+        @formatter ||= Formatters::AnsiFormatter.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/formatters/ansi_formatter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base_formatter'
+
+module TPTree
+  module Formatters
+    # AnsiFormatter provides ANSI color code formatting for terminal output
+    class AnsiFormatter < BaseFormatter
+      def colorize(text, color)
+        color_codes = {
+          black: 30, red: 31, green: 32, yellow: 33,
+          blue: 34, magenta: 35, cyan: 36, white: 37
+        }
+
+        code = color_codes[color] || 37
+        "\e[#{code}m#{text}\e[0m"
+      end
+    end
+  end
+end