ruby-prof 0.18.0-x64-mingw32

data/lib/ruby-prof/task.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rake'
+require 'rake/testtask'
+require 'fileutils'
+
+module RubyProf
+
+  # Define a task library for profiling unit tests with ruby-prof.
+  #
+  # All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #   output_dir - For each file specified an output
+  #                file with profile information will be
+  #                written to the output directory.
+  #                By default, the output directory is
+  #                called "profile" and is created underneath
+  #                the current working directory.
+  #
+  #   printer - Specifies the output printer.  Valid values include
+  #             :flat, :graph, :graph_html and :call_tree.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #                 will not be written out.
+  #
+  # Example:
+  #
+  #   require 'ruby-prof/task'
+  #
+  #   RubyProf::ProfileTask.new do |t|
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.output_dir = "c:/temp"
+  #     t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake profile                           # run tests normally
+  #   rake profile TEST=just_one_file.rb     # run just one test file.
+  #   rake profile TESTOPTS="-v"             # run in verbose mode
+  #   rake profile TESTOPTS="--runner=fox"   # use the fox test runner
+
+  class ProfileTask < Rake::TestTask
+    attr_accessor :output_dir
+    attr_accessor :min_percent
+    attr_accessor :printer
+
+    def initialize(name = :profile)
+      super(name)
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Profile" + (@name==:profile ? "" : " for #{@name}")
+
+      task @name do
+        create_output_directory
+
+        @ruby_opts.unshift( "-I#{lib_path}" )
+        @ruby_opts.unshift( "-w" ) if @warning
+        @ruby_opts.push("-S ruby-prof")
+        @ruby_opts.push("--printer #{@printer}")
+        @ruby_opts.push("--min_percent #{@min_percent}")
+
+        file_list.each do |file_path|
+          run_script(file_path)
+        end
+      end
+      self
+    end
+
+    # Run script
+    def run_script(script_path)
+      run_code = ''
+      RakeFileUtils.verbose(@verbose) do
+        file_name = File.basename(script_path, File.extname(script_path))
+        case @printer
+          when :flat, :graph, :call_tree
+            file_name += ".txt"
+          when :graph_html
+            file_name += ".html"
+          else
+            file_name += ".txt"
+        end
+
+        output_file_path = File.join(output_directory, file_name)
+
+        command_line = @ruby_opts.join(" ") +
+                      " --file=" + output_file_path +
+                      " " + script_path
+
+        puts "ruby " + command_line
+        # We have to catch the exeption to continue on.  However,
+        # the error message will have been output to STDERR
+        # already by the time we get here so we don't have to
+        # do that again
+        begin
+          ruby command_line
+        rescue => e
+          STDOUT << e << "\n"
+          STDOUT.flush
+        end
+        puts ""
+        puts ""
+      end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+
+    def create_output_directory
+      if not File.exist?(output_directory)
+        Dir.mkdir(output_directory)
+      end
+    end
+
+    def clean_output_directory
+      if File.exist?(output_directory)
+        files = Dir.glob(output_directory + '/*')
+        FileUtils.rm(files)
+      end
+    end
+
+    def option_list # :nodoc:
+      ENV['OPTIONS'] || @options.join(" ") || ""
+    end
+  end
+end

data/lib/ruby-prof/thread.rb

@@ -0,0 +1,35 @@
+module RubyProf
+  class Thread
+    def top_methods
+      self.methods.select do |method_info|
+        method_info.call_infos.detect(&:root?)
+      end
+    end
+
+    def top_call_infos
+      top_methods.map(&:call_infos).flatten.select(&:root?)
+    end
+
+    def total_time
+      self.top_methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          if call_info.parent.nil?
+            sum += call_info.total_time
+          end
+        end
+        sum
+      end
+    end
+
+    def wait_time
+      # wait_time, like self:time, is always method local
+      # thus we need to sum over all methods and call infos
+      self.methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          sum += call_info.wait_time
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -0,0 +1,3 @@
+module RubyProf
+  VERSION = "0.18.0"
+end

data/lib/unprof.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

data/ruby-prof.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby-prof/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-prof"
+
+  spec.homepage = "https://github.com/ruby-prof/ruby-prof/"
+  spec.summary = "Fast Ruby profiler"
+  spec.description = <<-EOF
+ruby-prof is a fast code profiler for Ruby. It is a C extension and
+therefore is many times faster than the standard Ruby profiler. It
+supports both flat and graph profiles.  For each method, graph profiles
+show how long the method ran, which methods called it and which
+methods it called. RubyProf generate both text and html and can output
+it to standard out or to a file.
+EOF
+  spec.license = 'BSD-2-Clause'
+  spec.version = RubyProf::VERSION
+
+  spec.author = "Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes"
+  spec.email = "shugo@ruby-lang.org, cfis@savagexi.com, rogerdpack@gmail.com, skaes@railsexpress.de"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.bindir = "bin"
+  spec.executables = ["ruby-prof", "ruby-prof-check-trace"]
+  spec.extensions = ["ext/ruby_prof/extconf.rb"]
+  spec.files = Dir['CHANGES',
+                   'LICENSE',
+                   'Rakefile',
+                   'README.rdoc',
+                   'ruby-prof.gemspec',
+                   'bin/ruby-prof',
+                   'bin/ruby-prof-check-trace',
+                   'doc/**/*',
+                   'examples/*',
+                   'ext/ruby_prof/extconf.rb',
+                   'ext/ruby_prof/*.c',
+                   'ext/ruby_prof/*.h',
+                   'ext/ruby_prof/vc/*.sln',
+                   'ext/ruby_prof/vc/*.vcxproj',
+                   'lib/ruby-prof.rb',
+                   'lib/unprof.rb',
+                   'lib/ruby-prof/*.rb',
+                   'lib/ruby-prof/assets/*.{html,png}',
+                   'lib/ruby-prof/profile/*.rb',
+                   'lib/ruby-prof/printers/*.rb',
+                   'test/*.rb']
+
+  spec.test_files = Dir["test/test_*.rb"]
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.date = Time.now.strftime('%Y-%m-%d')
+  spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('rake-compiler')
+  spec.add_development_dependency('rdoc')
+end

data/test/abstract_printer_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class AbstractPrinterTest < TestCase
+  def setup
+    @result = {}
+    @printer = RubyProf::AbstractPrinter.new(@result)
+    @options = {}
+    @printer.setup_options(@options)
+  end
+
+  def test_editor_uri
+    env = {}
+
+    with_const_stubbed('ENV', env) do
+      @options[:editor_uri] = 'nvim'
+
+      env['RUBY_PROF_EDITOR_URI'] = 'atm'
+      assert_equal('atm', @printer.editor_uri)
+
+      env['RUBY_PROF_EDITOR_URI'] = nil
+      assert_equal(false, @printer.editor_uri)
+
+      env.delete('RUBY_PROF_EDITOR_URI')
+      assert_equal('nvim', @printer.editor_uri)
+
+      with_const_stubbed('RUBY_PLATFORM', 'x86_64-darwin18') do
+        assert_equal('nvim', @printer.editor_uri)
+
+        @options.delete(:editor_uri)
+        assert_equal('txmt', @printer.editor_uri)
+      end
+      with_const_stubbed('RUBY_PLATFORM', 'windows') do
+        assert_equal(false, @printer.editor_uri)
+      end
+    end
+  end
+
+  private
+
+  def with_const_stubbed(name, value)
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    old_value = Object.const_get(name)
+
+    Object.const_set(name, value)
+    yield
+    Object.const_set(name, old_value)
+
+    $VERBOSE = old_verbose
+  end
+end

data/test/aggregate_test.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#   A   B   C
+#   |   |   |
+#   Z   A   A
+#       |   |
+#       Z   Z
+
+class AggClass
+  def z
+    sleep 1
+  end
+
+  def a
+    z
+  end
+
+  def b
+    a
+  end
+
+  def c
+    a
+  end
+end
+
+class AggregateTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_all_call_infos_are_not_recursive
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+    methods = result.threads.first.methods.sort.reverse
+    methods.each do |m|
+      m.call_infos.each do |ci|
+        assert(!ci.recursive?)
+      end
+    end
+  end
+
+  def test_call_infos
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
+
+    # Check AggClass#z
+    assert_equal('AggClass#z', method.full_name)
+    assert_equal(3, method.called)
+    assert_in_delta(3, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(3, method.children_time, 0.05)
+    assert_equal(3, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('AggregateTest#test_call_infos->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('AggregateTest#test_call_infos->AggClass#b->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[2]
+    assert_equal('AggregateTest#test_call_infos->AggClass#c->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+  end
+
+  def test_aggregates_parents
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
+
+    # Check AggClass#z
+    assert_equal('AggClass#z', method.full_name)
+
+    call_infos = method.aggregate_parents
+    assert_equal(1, call_infos.length)
+
+    call_info = call_infos.first
+    assert_equal('AggClass#a', call_info.parent.target.full_name)
+    assert_in_delta(3, call_info.total_time, 0.05)
+    assert_in_delta(0, call_info.wait_time, 0.05)
+    assert_in_delta(0, call_info.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+
+  def test_aggregates_children
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
+
+    # Check AggClass#a
+    assert_equal('AggClass#a', method.full_name)
+
+    call_infos = method.aggregate_children
+    assert_equal(1, call_infos.length)
+
+    call_info = call_infos.first
+    assert_equal('AggClass#z', call_info.target.full_name)
+    assert_in_delta(3, call_info.total_time, 0.05)
+    assert_in_delta(0, call_info.wait_time, 0.05)
+    assert_in_delta(0, call_info.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+end