trace_tree 0.1.5 → 0.2.1

data/lib/trace_tree/point/ccall_kernel_extend.rb

@@ -0,0 +1,14 @@
+class TraceTree
+  class Point
+    class CcallKernelExtend < Point
+      def parameters
+        callees[0].mixin
+      end
+
+      def self.event_class_method
+        [:c_call, Kernel, :extend]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_module_appendfeatures.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallModuleAppendfeatures < Point
+
+      def self.event_class_method
+        [:c_call, Module, :append_features]
+      end
+
+      def parameters
+        terminal.return_value
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_module_extendobject.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallModuleExtendobject < Point
+
+      def mixin
+        terminal.mixin
+      end
+
+      def self.event_class_method
+        [:c_call, Module, :extend_object]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_module_include.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallModuleInclude < Point
+
+      def self.event_class_method
+        [:c_call, Module, :include]
+      end
+
+      def parameters
+        callees[0].parameters
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_module_prepend.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallModulePrepend < Point
+
+      def self.event_class_method
+        [:c_call, Module, :prepend]
+      end
+
+      def parameters
+        callees[0].parameters
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_module_prependfeatures.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallModulePrependfeatures < Point
+
+      def self.event_class_method
+        [:c_call, Module, :prepend_features]
+      end
+
+      def parameters
+        terminal.return_value
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/ccall_thread_initialize.rb

@@ -0,0 +1,15 @@
+class TraceTree
+  class Point
+    class CcallThreadInitialize < Point
+
+      def self.event_class_method
+        [:c_call, Thread, :initialize]
+      end
+
+      def callees
+        [terminal.thread_begin]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/common.rb

@@ -0,0 +1,10 @@
+class TraceTree
+  class Point
+    class Common < Point
+      def self.event_class_method
+        :common
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/creturn_classthread_new.rb

@@ -0,0 +1,11 @@
+class TraceTree
+  class Point
+    class CreturnClassthreadNew < Point
+
+      def self.event_class_method
+        [:c_return, Thread.singleton_class, :new]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/creturn_module_appendfeatures.rb

@@ -0,0 +1,11 @@
+class TraceTree
+  class Point
+    class CreturnModuleAppendfeatures < Point
+
+      def self.event_class_method
+        [:c_return, Module, :append_features]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/creturn_module_extendobject.rb

@@ -0,0 +1,18 @@
+class TraceTree
+  class Point
+    class CreturnModuleExtendobject < Point
+
+      def initialize trace_point
+        super
+        @mixin = return_value.singleton_class.ancestors[1]
+      end
+
+      attr_reader :mixin
+
+      def self.event_class_method
+        [:c_return, Module, :extend_object]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/creturn_module_prependfeatures.rb

@@ -0,0 +1,11 @@
+class TraceTree
+  class Point
+    class CreturnModulePrependfeatures < Point
+
+      def self.event_class_method
+        [:c_return, Module, :prepend_features]
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/creturn_thread_initialize.rb

@@ -0,0 +1,12 @@
+class TraceTree
+  class Point
+    class CreturnThreadInitialize < Point
+
+      def self.event_class_method
+        [:c_return, Thread, :initialize]
+      end
+
+      attr_accessor :thread_begin
+    end
+  end
+end

data/lib/trace_tree/point/threadbegin.rb

@@ -0,0 +1,23 @@
+class TraceTree
+  class Point
+    class Threadbegin < Point
+
+      def self.event_class_method
+        [:thread_begin, nil, nil]
+      end
+
+      def class_name
+        ''
+      end
+
+      def method_name
+        :thread_run
+      end
+
+      def call_symbol
+        ''
+      end
+
+    end
+  end
+end

data/lib/trace_tree/point/threadend.rb

@@ -0,0 +1,22 @@
+class TraceTree
+  class Point
+    class Threadend < Point
+
+      def self.event_class_method
+        [:thread_end, nil, nil]
+      end
+
+      def class_name
+        ''
+      end
+
+      def method_name
+        :thread_run
+      end
+
+      def call_symbol
+        ''
+      end
+    end
+  end
+end

data/lib/trace_tree/point.rb

@@ -0,0 +1,168 @@
+require 'trace_tree/tree_graphable'
+require 'trace_tree/tree_htmlable'
+
+class TraceTree
+  class Point
+
+    include TreeGraphable
+    include TreeHtmlable
+
+    attr_reader :current, :thread
+    attr_accessor :terminal
+
+    Interfaces = [:event, :defined_class, :method_id, :path, :lineno]
+    attr_reader *Interfaces
+
+    class << self
+      def inherited base
+        bases << base
+      end
+
+      def classes
+        @classes ||= bases.each_with_object(Hash.new{|h| h[:common]}){|c, h| h[c.event_class_method] = c}
+      end
+
+      def bases
+        @bases ||= []
+      end
+
+      def hashify point
+        attrs = Interfaces.each_with_object({}) do |attr, hash|
+          hash[attr] = point.send attr
+        end
+        attrs.merge!({return_value: point.return_value}) if point.event =~ /return/
+        attrs.merge!({thread: point.thread}) if point.respond_to? :thread
+        attrs
+      end
+
+      def class_of? point
+        [point.event, point.defined_class, point.method_id] == event_class_method
+      end
+
+      def initialize_clone proto
+        super.tap do
+          instance_variable_set :@proto, proto
+        end
+      end
+
+      attr_reader :proto
+    end
+
+    def method_missing method_id, *args, &blk
+      raise NoMethodError, "NoMethodError: undefined method `#{method_id}' for #<#{self.class.proto or self.class.name}#{inspect}>"
+    end
+
+    def initialize trace_point
+      Interfaces.each do |i|
+        instance_variable_set "@#{i}", trace_point.send(i)
+      end
+      @return_value = trace_point.return_value if x_return?
+      @current = trace_point.binding.of_callers[3] unless thread?
+      @thread = thread? ? trace_point.self : current.send(:eval, 'Thread.current')
+    rescue => e
+      puts e
+    end
+
+    def c_call?
+      event == :c_call
+    end
+
+    def x_return?
+      event =~ /return/
+    end
+
+    def thread?
+      event =~ /thread/
+    end
+
+    def return_value
+      raise RuntimeError.new('RuntimeError: not supported by this event') unless x_return?
+      @return_value
+    end
+
+    def inspect
+      to_h.inspect
+    end
+
+    def to_h
+      self.class.hashify(self)
+    end
+
+    def terminate? point
+      same_method?(point) and ending?(point)
+    end
+
+    def same_method? point
+      point.defined_class == defined_class and point.method_id == method_id
+    end
+
+    def ending? point
+      (event == :b_return and point.event == :b_call) or
+        (event == :c_return and point.event == :c_call) or
+        (event == :return and point.event == :call) or
+        (event == :end and point.event == :class) or
+        (event == :thread_end and point.event == :thread_begin)
+    end
+
+    def << node
+      callees << node
+    end
+
+    def callees
+      @callees ||= []
+    end
+
+    def class_and_method
+      "#{_class_and_method}#{arg}"
+    end
+
+    def _class_and_method
+      @km ||= "#{class_name}#{call_symbol}#{method_name}"
+    end
+
+    def class_name
+      c_call? ? defined_class : current.klass
+    rescue => e
+      puts event
+    end
+
+    def method_name
+      c_call? ? method_id : current.frame_env
+    end
+
+    def call_symbol
+      c_call? ? '#' : current.call_symbol
+    end
+
+    def source_location
+      "#{path}:#{lineno}"
+    end
+
+    def arg
+      respond_to?(:parameters) ? "(#{parameters})" : nil
+    end
+
+    class Loader
+
+      attr_reader :point_classes
+
+      def initialize *enhancement
+        return @point_classes = Point.classes if enhancement.empty?
+        @point_classes = Point.classes.each_with_object(Point.classes.dup) do |entry, hash|
+          hash[entry[0]] = entry[1].clone.prepend *enhancement
+        end
+      end
+
+      def create point
+        point_klass = point_classes[[point.event, point.defined_class, point.method_id]]
+        point_klass.new point
+      end
+    end
+
+  end
+end
+
+Dir.glob(File.expand_path('../point/*', __FILE__)).each do |concreate_point_path|
+  load concreate_point_path
+  #puts "---->#{concreate_point_path}"
+end

data/lib/trace_tree/short_gem_path.rb

@@ -4,12 +4,14 @@ class TraceTree
   module ShortGemPath
 
     def source_location
-      "#{shorten_gem_path current.file}:#{current.line}"
+      #"#{shorten_gem_path current.file}:#{current.line}"
+      "#{shorten_gem_path path}:#{lineno}"
     end
 
     private
 
     def shorten_gem_path loc
+      return '' if loc.nil?
       GemPaths.each{|name, path| loc = loc.gsub(path, "$#{name}")}
       loc
     end

data/lib/trace_tree/tree_graphable.rb

@@ -7,6 +7,8 @@ class TraceTree
 
     def label_for_tree_graph
       "#{class_and_method} #{source_location}"
+      #"#{defined_class}#{current.call_symbol}#{method_id} #{path} #{lineno}"
+      #"#{defined_class} #{method_id} #{path} #{lineno}"
     end
 
     def children_for_tree_graph

data/lib/trace_tree/version.rb

@@ -1,3 +1,3 @@
 class TraceTree
-  VERSION = "0.1.5"
+  VERSION = "0.2.1"
 end

data/lib/trace_tree.rb

@@ -1,10 +1,12 @@
 require "trace_tree/version"
 require 'binding_of_callers/pry'
-require 'trace_tree/node'
+require 'trace_tree/point'
 require 'trace_tree/short_gem_path'
 require 'trace_tree/color'
 require 'trace_tree/tmp_file'
 require 'trace_tree/timer'
+require 'thread'
+require 'terminal-tableofhashes'
 
 class Binding
   def trace_tree *log, **opt, &to_do
@@ -14,75 +16,111 @@ end
 
 class TraceTree
 
+  Events = [:b_call, :b_return,
+            :c_call, :c_return,
+            :call, :return,
+            :class, :end,
+            :thread_begin, :thread_end]
+
   def initialize bi
     @bi = bi
-    @trace_points = []
+    @trace_points = Queue.new
     @timer = Timer.new
   end
 
   def generate *log, **opt, &to_do
     @opt = opt
     @log = dump_location *log
-    @node_class = optional_node **opt
+    enhance_point **opt
     @build_command = opt[:html] ? :tree_html_full : :tree_graph
-    start_trace
-    bi.eval('self').instance_eval &to_do
-  ensure
-    stop_trace
-  end
-
-  private
+    @ignore = opt[:ignore] || {}
+    here = bi.eval('self')
 
-  attr_reader :bi, :trace_points, :log, :build_command, :timer, :opt
-
-  def start_trace
+    #start_trace
     timer[:trace]
-    @tp = TracePoint.trace(:call, :b_call, :raise, :c_call) do |point|
-      trace_points << @node_class.new(point) if wanted? point
+    @tp = TracePoint.new(*Events) do |point|
+      trace_points << point_loader.create(point) if wanted? point
     end
-  end
+    @tp.enable
 
-  def stop_trace
+    here.instance_eval &to_do
+  ensure
+    #stop_trace
     return unless @tp
     @tp.disable
     timer[:trace]
     dump_trace_tree
   end
 
+  private
+
+  attr_reader :bi, :trace_points, :log, :build_command, :timer, :opt, :point_loader
+
   def dump_location *log
     return TmpFile.new opt[:tmp] if opt[:tmp]
     log.empty? ? STDOUT : log[0]
   end
 
-  def optional_node opt
-    Class.new TraceTree::Node do
-      prepend TraceTree::ShortGemPath unless opt[:gem] == false
-      prepend TraceTree::Color unless opt[:color] == false
-    end
+  def enhance_point opt
+    enhancement = []
+    enhancement << TraceTree::Color unless opt[:color] == false
+    enhancement << TraceTree::ShortGemPath unless opt[:gem] == false
+    @point_loader = Point::Loader.new *enhancement
   end
 
   def dump_trace_tree
     timer[:tree]
-    tree = sort(trace_points).send build_command
+    tree = sort(trace_points_array).send build_command
     timer[:tree]
     log.puts tree
     log.puts timer.to_s if opt[:timer]
+  rescue => e
+    log.puts timer.to_s
+    log.puts e
+    log.puts Terminal::Table.from_hashes trace_points_array.map(&:to_h)
   end
 
   def wanted? trace_point
-    trace_point.event != :c_call or trace_point.method_id == :throw
+    @ignore.any? do |attr, pattern|
+      pattern =~ trace_point.send(attr)
+    end ? false : true
   end
 
-  def sort stack
-    hash = {}
-    stack.each do |call|
-      unless hash.empty?
-        parent = hash[call.parent_stack]
-        parent << call if parent
+  def sort trace_points
+    stacks = Hash.new{|h, thread| h[thread] = []}
+    initialized_threads, began_threads = {}, {}
+
+    trace_points.each do |point|
+      stack = stacks[point.thread]
+      unless stack.empty?
+        if point.terminate? stack.last
+          stack.last.terminal = point
+          stack.pop
+        else
+          stack.last << point
+          stack << point
+        end
+      else
+        stack << point
       end
-      hash[call.whole_stack] = call
+      initialized_threads[point.return_value] = point if Point::CreturnThreadInitialize.class_of? point
+      began_threads[point.thread] = point if Point::Threadbegin.class_of? point
     end
-    stack[0]
+
+    initialized_threads.each do |thread, point|
+      point.thread_begin = began_threads[thread]
+    end
+
+    stacks[trace_points.first.thread][0].
+      callees[0].
+      callees[0]
+  end
+
+  def trace_points_array
+    return @tpa if defined? @tpa
+    @tpa = []
+    @tpa << trace_points.deq until trace_points.size == 0
+    @tpa
   end
 
 end

data/trace_tree.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["ken"]
   spec.email         = ["block24block@gmail.com"]
 
-  spec.summary       = %q{Print TracePoint(normal ruby call, block call, raise call, throw call) in tree graph}
+  spec.summary       = %q{Print TracePoint(:b_call, :b_return, :c_call, :c_return, :call, :return, :class, :end, :thread_begin, :thread_end) in tree view, to console or html}
   spec.homepage      = "https://github.com/turnon/trace_tree"
   spec.license       = "MIT"
 
@@ -27,4 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "binding_of_callers", "0.1.3"
   spec.add_dependency "tree_graph", "~> 0.2.0"
   spec.add_dependency "tree_html", "~> 0.1.0"
+  spec.add_dependency "activesupport", ">= 5.0.0"
+  spec.add_dependency "terminal-tableofhashes", "~> 0.1.0"
 end