ruby-prof 1.7.2 → 2.0.0

data/lib/ruby-prof/printers/call_stack_printer.rb

@@ -1,180 +1,168 @@
-# encoding: utf-8
-
-require 'erb'
-require 'fileutils'
-require 'base64'
-require 'set'
-require 'stringio'
-
-module RubyProf
-  # Prints a HTML visualization of the call tree.
-  #
-  # To use the printer:
-  #
-  #   result = RubyProf.profile do
-  #     [code to profile]
-  #   end
-  #
-  #   printer = RubyProf::CallStackPrinter.new(result)
-  #   printer.print(STDOUT)
-
-  class CallStackPrinter < AbstractPrinter
-    include ERB::Util
-
-    # Specify print options.
-    #
-    # options - Hash table
-    #   :min_percent - Number 0 to 100 that specifes the minimum
-    #                  %self (the methods self time divided by the
-    #                  overall total time) that a method must take
-    #                  for it to be printed out in the report.
-    #                  Default value is 0.
-    #
-    #   :threshold   - a float from 0 to 100 that sets the threshold of
-    #                  results displayed.
-    #                  Default value is 1.0
-    #
-    #   :title       - a String to overide the default "ruby-prof call tree"
-    #                  title of the report.
-    #
-    #   :expansion   - a float from 0 to 100 that sets the threshold of
-    #                  results that are expanded, if the percent_total
-    #                  exceeds it.
-    #                  Default value is 10.0
-    #
-    #   :application - a String to overide the name of the application,
-    #                  as it appears on the report.
-    def print(output = STDOUT, options = {})
-      setup_options(options)
-      output << @erb.result(binding)
-    end
-
-    # :enddoc:
-    def setup_options(options)
-      super(options)
-      @erb = ERB.new(self.template)
-    end
-
-    def print_stack(output, visited, call_tree, parent_time)
-      total_time = call_tree.total_time
-      percent_parent = (total_time/parent_time)*100
-      percent_total = (total_time/@overall_time)*100
-      return unless percent_total > min_percent
-      color = self.color(percent_total)
-      visible = percent_total >= threshold
-      expanded = percent_total >= expansion
-      display = visible ? "block" : "none"
-
-      output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
-
-      if visited.include?(call_tree)
-        output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
-        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
-      else
-        visited << call_tree
-
-        if call_tree.children.empty?
-          output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
-        else
-          visible_children = call_tree.children.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
-          image = visible_children ? (expanded ? "minus" : "plus") : "empty"
-          output << "<a href=\"#\" class=\"toggle #{image}\" ></a>" << "\n"
-        end
-        output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
-                                                            link(call_tree.target, false), graph_link(call_tree)] << "\n"
-
-        unless call_tree.children.empty?
-          output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
-          call_tree.children.sort_by{|c| -c.total_time}.each do |child_call_tree|
-            print_stack(output, visited, child_call_tree, total_time)
-          end
-          output << '</ul>' << "\n"
-        end
-
-        visited.delete(call_tree)
-      end
-      output << '</li>' << "\n"
-    end
-
-    def name(call_tree)
-      method = call_tree.target
-      method.full_name
-    end
-
-    def link(method, recursive)
-      method_name = "#{recursive ? '*' : ''}#{method.full_name}"
-      if method.source_file.nil?
-        h method_name
-      else
-        file = File.expand_path(method.source_file)
-       "<a href=\"file://#{file}##{method.line}\">#{h method_name}</a>"
-      end
-    end
-
-    def graph_link(call_tree)
-      total_calls = call_tree.target.called
-      totals = total_calls.to_s
-      "[#{call_tree.called} calls, #{totals} total]"
-    end
-
-    def method_href(method)
-      h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
-    end
-
-    def total_time(call_trees)
-      sum(call_trees.map{|ci| ci.total_time})
-    end
-
-    def sum(a)
-      a.inject(0.0){|s,t| s+=t}
-    end
-
-    def dump(ci)
-      $stderr.printf "%s/%d t:%f s:%f w:%f  \n", ci, ci.object_id, ci.total_time, ci.self_time, ci.wait_time
-    end
-
-    def color(p)
-      case i = p.to_i
-      when 0..5
-        "01"
-      when 5..10
-        "05"
-      when 100
-        "9"
-      else
-        "#{i/10}"
-      end
-    end
-
-    def application
-      @options[:application] || $PROGRAM_NAME
-    end
-
-    def arguments
-      ARGV.join(' ')
-    end
-
-    def title
-      @title ||= @options.delete(:title) || "ruby-prof call tree"
-    end
-
-    def threshold
-      @options[:threshold] || 1.0
-    end
-
-    def expansion
-      @options[:expansion] || 10.0
-    end
-
-    def base64_image
-      @data ||= begin
-        file = open_asset('call_stack_printer.png')
-        Base64.encode64(file).gsub(/\n/, '')
-      end
-    end
-
-    def template
-      open_asset('call_stack_printer.html.erb')
-    end
-  end
-end
+# encoding: utf-8
+
+require 'erb'
+require 'fileutils'
+require 'base64'
+require 'set'
+require 'stringio'
+
+module RubyProf
+  # Prints a HTML visualization of the call tree.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallStackPrinter.new(result)
+  #   printer.print(STDOUT)
+
+  class CallStackPrinter < AbstractPrinter
+    include ERB::Util
+
+    # Specify print options.
+    #
+    # output     - Any IO object, including STDOUT or a file.
+    #
+    # Keyword arguments:
+    #   title:       - a String to override the default "ruby-prof call stack"
+    #                  title of the report.
+    #
+    #   threshold:   - a float from 0 to 100 that sets the threshold of
+    #                  results displayed.
+    #                  Default value is 1.0
+    #
+    #   expansion:   - a float from 0 to 100 that sets the threshold of
+    #                  results that are expanded, if the percent_total
+    #                  exceeds it.
+    #                  Default value is 10.0
+    #
+    #   application: - a String to override the name of the application,
+    #                  as it appears on the report.
+    #
+    # Also accepts min_percent:, max_percent:, filter_by:, and sort_method:
+    # from AbstractPrinter.
+    def print(output = STDOUT, title: "ruby-prof call stack", threshold: 1.0,
+              expansion: 10.0, application: $PROGRAM_NAME,
+              min_percent: 0, max_percent: 100, filter_by: :self_time, sort_method: nil, **)
+      @min_percent = min_percent
+      @max_percent = max_percent
+      @filter_by = filter_by
+      @sort_method = sort_method
+      @title = title
+      @threshold = threshold
+      @expansion = expansion
+      @application = application
+      output << ERB.new(self.template).result(binding)
+    end
+
+    def print_stack(output, visited, call_tree, parent_time)
+      total_time = call_tree.total_time
+      percent_parent = (total_time/parent_time)*100
+      percent_total = (total_time/@overall_time)*100
+      return unless percent_total > min_percent
+      color = self.color(percent_total)
+      visible = percent_total >= threshold
+      expanded = percent_total >= expansion
+      display = visible ? "block" : "none"
+
+      output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
+
+      if visited.include?(call_tree)
+        output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
+      else
+        visited << call_tree
+
+        if call_tree.children.empty?
+          output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        else
+          visible_children = call_tree.children.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
+          image = visible_children ? (expanded ? "minus" : "plus") : "empty"
+          output << "<a href=\"#\" class=\"toggle #{image}\" ></a>" << "\n"
+        end
+        output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
+                                                            link(call_tree.target, false), graph_link(call_tree)] << "\n"
+
+        unless call_tree.children.empty?
+          output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
+          call_tree.children.sort_by{|c| -c.total_time}.each do |child_call_tree|
+            print_stack(output, visited, child_call_tree, total_time)
+          end
+          output << '</ul>' << "\n"
+        end
+
+        visited.delete(call_tree)
+      end
+      output << '</li>' << "\n"
+    end
+
+    def name(call_tree)
+      method = call_tree.target
+      method.full_name
+    end
+
+    def link(method, recursive)
+      method_name = "#{recursive ? '*' : ''}#{method.full_name}"
+      if method.source_file.nil?
+        h method_name
+      else
+        file = File.expand_path(method.source_file)
+       "<a href=\"file://#{file}##{method.line}\">#{h method_name}</a>"
+      end
+    end
+
+    def graph_link(call_tree)
+      total_calls = call_tree.target.called
+      totals = total_calls.to_s
+      "[#{call_tree.called} calls, #{totals} total]"
+    end
+
+    def method_href(method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
+    end
+
+    def total_time(call_trees)
+      sum(call_trees.map{|ci| ci.total_time})
+    end
+
+    def sum(a)
+      a.inject(0.0){|s,t| s+=t}
+    end
+
+    def dump(ci)
+      $stderr.printf "%s/%d t:%f s:%f w:%f  \n", ci, ci.object_id, ci.total_time, ci.self_time, ci.wait_time
+    end
+
+    def color(p)
+      case i = p.to_i
+      when 0..5
+        "01"
+      when 5..10
+        "05"
+      when 100
+        "9"
+      else
+        "#{i/10}"
+      end
+    end
+
+    attr_reader :application, :title, :threshold, :expansion
+
+    def arguments
+      ARGV.join(' ')
+    end
+
+    def base64_image
+      @data ||= begin
+        file = open_asset('call_stack_printer.png')
+        Base64.encode64(file).gsub(/\n/, '')
+      end
+    end
+
+    def template
+      open_asset('call_stack_printer.html.erb')
+    end
+  end
+end

data/lib/ruby-prof/printers/call_tree_printer.rb

@@ -1,145 +1,132 @@
-# encoding: utf-8
-
-require 'fiber'
-require 'thread'
-require 'fileutils'
-
-module RubyProf
-  # Generates profiling information in callgrind format for use by
-  # kcachegrind and similar tools.
-
-  class CallTreePrinter < AbstractPrinter
-    def calltree_name(method_info)
-      klass_path = method_info.klass_name.gsub("::", '/')
-      result = "#{klass_path}::#{method_info.method_name}"
-
-      case method_info.klass_flags
-        when 0x2
-          "#{result}^"
-        when 0x4
-          "#{result}^"
-        when 0x8
-         "#{result}*"
-        else
-         result
-      end
-    end
-
-    def determine_event_specification_and_value_scale
-      @event_specification = "events: "
-      case @result.measure_mode
-        when RubyProf::PROCESS_TIME
-          @value_scale = RubyProf::CLOCKS_PER_SEC
-          @event_specification << 'process_time'
-        when RubyProf::WALL_TIME
-          @value_scale = 1_000_000
-          @event_specification << 'wall_time'
-        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
-          @value_scale = 1
-          @event_specification << 'allocations'
-        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
-          @value_scale = 1
-          @event_specification << 'memory'
-        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
-          @value_scale = 1
-          @event_specification << 'gc_runs'
-        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
-          @value_scale = 1000000
-          @event_specification << 'gc_time'
-        else
-          raise "Unknown measure mode: #{RubyProf.measure_mode}"
-      end
-    end
-
-    def print(options = {})
-      validate_print_params(options)
-      setup_options(options)
-      determine_event_specification_and_value_scale
-      print_threads
-    end
-
-    def validate_print_params(options)
-      if options.is_a?(IO)
-        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
-      elsif !options.is_a?(Hash)
-        raise ArgumentError, "#{self.class.name}#print requires an options hash"
-      end
-    end
-
-    def print_threads
-      remove_subsidiary_files_from_previous_profile_runs
-      @result.threads.each do |thread|
-        print_thread(thread)
-      end
-    end
-
-    def convert(value)
-      (value * @value_scale).round
-    end
-
-    def file(method)
-      method.source_file ? File.expand_path(method.source_file) : ''
-    end
-
-    def print_thread(thread)
-      File.open(file_path_for_thread(thread), "w") do |f|
-        print_headers(f, thread)
-        thread.methods.reverse_each do |method|
-          print_method(f, method)
-        end
-      end
-    end
-
-    def path
-      @options[:path] || "."
-    end
-
-    def self.needs_dir?
-      true
-    end
-
-    def remove_subsidiary_files_from_previous_profile_runs
-      pattern = ["callgrind.out", $$, "*"].join(".")
-      files = Dir.glob(File.join(path, pattern))
-      FileUtils.rm_f(files)
-    end
-
-    def file_name_for_thread(thread)
-      if thread.fiber_id == Fiber.current.object_id
-        ["callgrind.out", $$].join(".")
-      else
-        ["callgrind.out", $$, thread.fiber_id].join(".")
-      end
-    end
-
-    def file_path_for_thread(thread)
-      File.join(path, file_name_for_thread(thread))
-    end
-
-    def print_headers(output, thread)
-      output << "#{@event_specification}\n\n"
-      # this doesn't work. kcachegrind does not fully support the spec.
-      # output << "thread: #{thread.id}\n\n"
-    end
-
-    def print_method(output, method)
-      # Print out the file and method name
-      output << "fl=#{file(method)}\n"
-      output << "fn=#{self.calltree_name(method)}\n"
-
-      # Now print out the function line number and its self time
-      output << "#{method.line} #{convert(method.self_time)}\n"
-
-      # Now print out all the children methods
-      method.call_trees.callees.each do |callee|
-        output << "cfl=#{file(callee.target)}\n"
-        output << "cfn=#{self.calltree_name(callee.target)}\n"
-        output << "calls=#{callee.called} #{callee.line}\n"
-
-        # Print out total times here!
-        output << "#{callee.line} #{convert(callee.total_time)}\n"
-      end
-      output << "\n"
-    end
-  end
-end
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'fiber'
+require 'thread'
+require 'fileutils'
+
+module RubyProf
+  # Generates profiling information in callgrind format for use by
+  # kcachegrind and similar tools.
+
+  class CallTreePrinter < AbstractPrinter
+    def calltree_name(method_info)
+      klass_path = method_info.klass_name.gsub("::", '/')
+      result = "#{klass_path}::#{method_info.method_name}"
+
+      case method_info.klass_flags
+        when 0x2
+          "#{result}^"
+        when 0x4
+          "#{result}^"
+        when 0x8
+         "#{result}*"
+        else
+         result
+      end
+    end
+
+    def determine_event_specification_and_value_scale
+      @event_specification = String.new("events: ")
+      case @result.measure_mode
+        when RubyProf::PROCESS_TIME
+          @value_scale = RubyProf::CLOCKS_PER_SEC
+          @event_specification << 'process_time'
+        when RubyProf::WALL_TIME
+          @value_scale = 1_000_000
+          @event_specification << 'wall_time'
+        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+          @value_scale = 1
+          @event_specification << 'allocations'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @event_specification << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @event_specification << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
+      end
+    end
+
+    def print(path: ".", **)
+      @path = path
+      determine_event_specification_and_value_scale
+      print_threads
+    end
+
+    def print_threads
+      remove_subsidiary_files_from_previous_profile_runs
+      @result.threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def convert(value)
+      (value * @value_scale).round
+    end
+
+    def file(method)
+      method.source_file ? File.expand_path(method.source_file) : ''
+    end
+
+    def print_thread(thread)
+      File.open(file_path_for_thread(thread), "w") do |f|
+        print_headers(f, thread)
+        thread.methods.reverse_each do |method|
+          print_method(f, method)
+        end
+      end
+    end
+
+    attr_reader :path
+
+    def self.needs_dir?
+      true
+    end
+
+    def remove_subsidiary_files_from_previous_profile_runs
+      pattern = ["callgrind.out", $$, "*"].join(".")
+      files = Dir.glob(File.join(path, pattern))
+      FileUtils.rm_f(files)
+    end
+
+    def file_name_for_thread(thread)
+      if thread.fiber_id == Fiber.current.object_id
+        ["callgrind.out", $$].join(".")
+      else
+        ["callgrind.out", $$, thread.fiber_id].join(".")
+      end
+    end
+
+    def file_path_for_thread(thread)
+      File.join(path, file_name_for_thread(thread))
+    end
+
+    def print_headers(output, thread)
+      output << "#{@event_specification}\n\n"
+      # this doesn't work. kcachegrind does not fully support the spec.
+      # output << "thread: #{thread.id}\n\n"
+    end
+
+    def print_method(output, method)
+      # Print out the file and method name
+      output << "fl=#{file(method)}\n"
+      output << "fn=#{self.calltree_name(method)}\n"
+
+      # Now print out the function line number and its self time
+      output << "#{method.line} #{convert(method.self_time)}\n"
+
+      # Now print out all the children methods
+      method.call_trees.callees.each do |callee|
+        output << "cfl=#{file(callee.target)}\n"
+        output << "cfn=#{self.calltree_name(callee.target)}\n"
+        output << "calls=#{callee.called} #{callee.line}\n"
+
+        # Print out total times here!
+        output << "#{callee.line} #{convert(callee.total_time)}\n"
+      end
+      output << "\n"
+    end
+  end
+end