ruby-prof 1.7.2 → 2.0.0

data/lib/ruby-prof/call_tree.rb

@@ -1,57 +1,57 @@
-# encoding: utf-8
-
-module RubyProf
-  # The CallTree class is used to track the relationships between methods. It is a helper class used by
-  # RubyProf::MethodInfo to keep track of which methods called a given method and which methods a given
-  # method called. Each CallTree has a parent and target method. You cannot create a CallTree object directly,
-  # they are generated while running a profile.
-  class CallTree
-    # The number of times the parent method called the target method
-    def called
-      self.measurement.called
-    end
-
-    # The total time resulting from the parent method calling the target method
-    def total_time
-      self.measurement.total_time
-    end
-
-    # The self time (of the parent) resulting from the parent method calling the target method
-    def self_time
-      self.measurement.self_time
-    end
-
-    # The wait time (of the parent) resulting from the parent method calling the target method
-    def wait_time
-      self.measurement.wait_time
-    end
-
-    # The time spent in child methods resulting from the parent method calling the target method
-    def children_time
-      self.total_time - self.self_time - self.wait_time
-    end
-
-    # Compares two CallTree instances. The comparison is based on the CallTree#parent, CallTree#target,
-    # and total time.
-    def <=>(other)
-      if self.target == other.target && self.parent == other.parent
-        0
-      elsif self.total_time < other.total_time
-        -1
-      elsif self.total_time > other.total_time
-        1
-      else
-        self.target.full_name <=> other.target.full_name
-      end
-    end
-
-    # :nodoc:
-    def to_s
-      "<#{self.class.name} - #{self.target.full_name}>"
-    end
-
-    def inspect
-      self.to_s
-    end
-  end
-end
+# encoding: utf-8
+
+module RubyProf
+  # The CallTree class is used to track the relationships between methods. It is a helper class used by
+  # RubyProf::MethodInfo to keep track of which methods called a given method and which methods a given
+  # method called. Each CallTree has a parent and target method. You cannot create a CallTree object directly,
+  # they are generated while running a profile.
+  class CallTree
+    # The number of times the parent method called the target method
+    def called
+      self.measurement.called
+    end
+
+    # The total time resulting from the parent method calling the target method
+    def total_time
+      self.measurement.total_time
+    end
+
+    # The self time (of the parent) resulting from the parent method calling the target method
+    def self_time
+      self.measurement.self_time
+    end
+
+    # The wait time (of the parent) resulting from the parent method calling the target method
+    def wait_time
+      self.measurement.wait_time
+    end
+
+    # The time spent in child methods resulting from the parent method calling the target method
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    # Compares two CallTree instances. The comparison is based on the CallTree#parent, CallTree#target,
+    # and total time.
+    def <=>(other)
+      if self.target == other.target && self.parent == other.parent
+        0
+      elsif self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      else
+        self.target.full_name <=> other.target.full_name
+      end
+    end
+
+    # :nodoc:
+    def to_s
+      "<#{self.class.name} - #{self.target.full_name}>"
+    end
+
+    def inspect
+      self.to_s
+    end
+  end
+end

data/lib/ruby-prof/call_tree_visitor.rb

@@ -1,36 +1,36 @@
-module RubyProf
-  # The call info visitor class does a depth-first traversal across a
-  # list of call infos. At each call_tree node, the visitor executes
-  # the block provided in the #visit method. The block is passed two
-  # parameters, the event and the call_tree instance. Event will be
-  # either :enter or :exit.
-  #
-  #   visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
-  #
-  #   method_names = Array.new
-  #
-  #   visitor.visit do |call_tree, event|
-  #     method_names << call_tree.target.full_name if event == :enter
-  #   end
-  #
-  #   puts method_names
-  class CallTreeVisitor
-    def initialize(call_tree)
-      @call_tree = call_tree
-    end
-
-    def visit(&block)
-      visit_call_tree(@call_tree, &block)
-    end
-
-    private
-
-    def visit_call_tree(call_tree, &block)
-      yield call_tree, :enter
-      call_tree.children.each do |child|
-        visit_call_tree(child, &block)
-      end
-      yield call_tree, :exit
-    end
-  end
-end
+module RubyProf
+  # The call info visitor class does a depth-first traversal across a
+  # list of call infos. At each call_tree node, the visitor executes
+  # the block provided in the #visit method. The block is passed two
+  # parameters, the event and the call_tree instance. Event will be
+  # either :enter or :exit.
+  #
+  #   visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
+  #
+  #   method_names = Array.new
+  #
+  #   visitor.visit do |call_tree, event|
+  #     method_names << call_tree.target.full_name if event == :enter
+  #   end
+  #
+  #   puts method_names
+  class CallTreeVisitor
+    def initialize(call_tree)
+      @call_tree = call_tree
+    end
+
+    def visit(&block)
+      visit_call_tree(@call_tree, &block)
+    end
+
+    private
+
+    def visit_call_tree(call_tree, &block)
+      yield call_tree, :enter
+      call_tree.children.each do |child|
+        visit_call_tree(child, &block)
+      end
+      yield call_tree, :exit
+    end
+  end
+end

data/lib/ruby-prof/measurement.rb

@@ -1,17 +1,17 @@
-module RubyProf
-  # The Measurement class is a helper class used by RubyProf::MethodInfo to store information about the method.
-  # You cannot create a CallTree object directly, they are generated while running a profile.
-  class Measurement
-    def children_time
-      self.total_time - self.self_time - self.wait_time
-    end
-
-    def to_s
-      "c: #{called}, tt: #{total_time}, st: #{self_time}"
-    end
-
-    def inspect
-      super + "(#{self.to_s})"
-    end
-  end
-end
+module RubyProf
+  # The Measurement class is a helper class used by RubyProf::MethodInfo to store information about the method.
+  # You cannot create a CallTree object directly, they are generated while running a profile.
+  class Measurement
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    def to_s
+      "c: #{called}, tt: #{total_time}, st: #{self_time}"
+    end
+
+    def inspect
+      super + "(#{self.to_s})"
+    end
+  end
+end

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

@@ -17,60 +17,46 @@ module RubyProf
       @output = nil
     end
 
-    # Returns the min_percent of time a method must take to be included in a profiling report
-    def min_percent
-      @options[:min_percent] || 0
-    end
-
-    # Returns the max_percent of time a method can take to be included in a profiling report
-    def max_percent
-      @options[:max_percent] || 100
-    end
-
-    # Returns the method to filter methods by (when using min_percent and max_percent)
-    def filter_by
-      @options[:filter_by] || :self_time
-    end
+    attr_reader :min_percent, :max_percent, :filter_by, :sort_method
 
     # Returns the time format used to show when a profile was run
     def time_format
       '%A, %B %-d at %l:%M:%S %p (%Z)'
     end
 
-    # Returns how profile data should be sorted
-    def sort_method
-      @options[:sort_method]
-    end
-
     # Prints a report to the provided output.
     #
     # output - Any IO object, including STDOUT or a file.
     # The default value is STDOUT.
     #
-    # options - Hash of print options. Note that each printer can
-    # define its own set of options.
-    #
-    #   :min_percent - Number 0 to 100 that specifies the minimum
+    # Keyword arguments:
+    #   min_percent  - Number 0 to 100 that specifies 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.
     #
-    #   :sort_method - Specifies method used for sorting method infos.
+    #   max_percent  - Number 0 to 100 that specifies the maximum
+    #                  %self for methods to include.
+    #                  Default value is 100.
+    #
+    #   filter_by    - Which time metric to use when applying
+    #                  min_percent and max_percent filters.
+    #                  Default value is :self_time.
+    #
+    #   sort_method  - Specifies method used for sorting method infos.
     #                  Available values are :total_time, :self_time,
-    #                  :wait_time, :children_time
-    #                  Default value is :total_time
-    def print(output = STDOUT, options = {})
+    #                  :wait_time, :children_time.
+    #                  Default value depends on the printer.
+    def print(output = STDOUT, min_percent: 0, max_percent: 100, filter_by: :self_time, sort_method: nil, **)
       @output = output
-      setup_options(options)
+      @min_percent = min_percent
+      @max_percent = max_percent
+      @filter_by = filter_by
+      @sort_method = sort_method
       print_threads
     end
 
-    # :nodoc:
-    def setup_options(options = {})
-      @options = options
-    end
-
     def method_location(method)
       if method.source_file
         "#{method.source_file}:#{method.line}"

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

@@ -1,53 +1,53 @@
-# encoding: utf-8
-
-module RubyProf
-  # Prints out the call graph based on CallTree instances. This
-  # is mainly for debugging purposes as it provides access into
-  # into RubyProf's internals.
-  #
-  # To use the printer:
-  #
-  #   result = RubyProf.profile do
-  #     [code to profile]
-  #   end
-  #
-  #   printer = RubyProf::CallInfoPrinter.new(result)
-  #   printer.print(STDOUT)
-  class CallInfoPrinter < AbstractPrinter
-    TIME_WIDTH = 0
-
-    private
-
-    def print_header(thread)
-      @output << "----------------------------------------------------\n"
-      @output << "Thread ID: #{thread.id}\n"
-      @output << "Fiber ID: #{thread.fiber_id}\n"
-      @output << "Total Time: #{thread.total_time}\n"
-      @output << "Sort by: #{sort_method}\n"
-      @output << "\n"
-    end
-
-    def print_methods(thread)
-      visitor = CallTreeVisitor.new(thread.call_tree)
-
-      visitor.visit do |call_tree, event|
-        if event == :enter
-          @output << "  " * call_tree.depth
-          @output << call_tree.target.full_name
-          @output << " ("
-          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.total_time)}, "
-          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.self_time)}, "
-          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.wait_time)}, "
-          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.children_time)}, "
-          @output << "call:#{call_tree.called}, "
-          @output << ")"
-          @output << "\n"
-        end
-      end
-    end
-
-    def print_footer(thread)
-      @output << "\n" << "\n"
-    end
-  end
-end
+# encoding: utf-8
+
+module RubyProf
+  # Prints out the call graph based on CallTree instances. This
+  # is mainly for debugging purposes as it provides access into
+  # into RubyProf's internals.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallInfoPrinter.new(result)
+  #   printer.print(STDOUT)
+  class CallInfoPrinter < AbstractPrinter
+    TIME_WIDTH = 0
+
+    private
+
+    def print_header(thread)
+      @output << "----------------------------------------------------\n"
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Fiber ID: #{thread.fiber_id}\n"
+      @output << "Total Time: #{thread.total_time}\n"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      visitor = CallTreeVisitor.new(thread.call_tree)
+
+      visitor.visit do |call_tree, event|
+        if event == :enter
+          @output << "  " * call_tree.depth
+          @output << call_tree.target.full_name
+          @output << " ("
+          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.total_time)}, "
+          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.self_time)}, "
+          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.wait_time)}, "
+          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.children_time)}, "
+          @output << "call:#{call_tree.called}, "
+          @output << ")"
+          @output << "\n"
+        end
+      end
+    end
+
+    def print_footer(thread)
+      @output << "\n" << "\n"
+    end
+  end
+end