browser-prof 1.2.3

data/.gitignore

@@ -0,0 +1,2 @@
+rails_test/*
+pkg/*

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Revolution Health Group LLC. All rights reserved.
+
+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.rdoc

@@ -0,0 +1,41 @@
+= Browser-prof
+
+This is a simple tool to profile single web requests in Rails using the power or ruby-prof.
+This gem is a based on the discontinued Browser Profiler (http://rubyforge.org/projects/browser-prof).
+
+* Easy walking through complex changes
+* Low overhead in development mode
+* MIT licensed
+
+== Installation & basic usage
+
+Installing browser-prof as a Ruby gem is currently broken, so you need to use it as a plugin:
+
+  $ ./script/plugin install http://github.com/barttenbrinke/browser-prof.git
+
+== Profiling
+
+Add ruby-prof to your Gemfile, run bundle install and start op your server environment.
+To profile, just open any url:
+
+  $ http://0.0.0.0:3000/some/action?browser_profile!
+
+On the botton of your page a html ruby-prof trace will be appended.
+Please note that the action will take lot longer, as it will be passed through ruby-prof.
+
+If you want to profile PDF, Json or post actions, just run the following command:
+  $ http://0.0.0.0:3000/some/action.js?file_profile!
+
+This will write the results to /log/. You can take a look at this through any browser.
+  $ open log/profile_out.html
+
+== Additional information
+
+Browser-profile was originally designed and built by Aaron Batalion (aaron@hungrymachine.com)
+and is now maintained by Bart ten Brinke.
+
+Do you have a rails application that is not performing as it should? If you need
+an expert to analyze your application, feel free to contact either Willem van
+Bergen (willem@railsdoctors.com) or Bart ten Brinke (bart@railsdoctors.com).
+
+* railsdoctors homepage: http://railsdoctors.com

data/Rakefile

@@ -0,0 +1,8 @@
+Dir[File.dirname(__FILE__) + "/tasks/*.rake"].each { |file| load(file) }
+
+# Register the gem release tasks in the gem namespace
+GithubGem::RakeTasks.new(:gem)
+
+# Set the RSpec runner with specdoc output as default task.
+task :default => "spec:specdoc"
+

data/browser-prof.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+  s.name    = "browser-prof"
+
+  # Do not set the version and date field manually, this is done by the release script
+  s.version = "1.2.3"
+  s.date    = "2011-02-17"
+
+  s.summary     = "Rails tool to to profile single requests using ruby-prof."
+  s.description = <<-eos
+    This is a simple tool to profile single web requests in Rails using the power or ruby-prof.
+  eos
+
+  s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
+  s.extra_rdoc_files = ['README.rdoc']
+
+  s.requirements << "ruby-prof gem is required."
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2.0')
+  s.add_development_dependency('ruby-prof')
+
+  s.authors  = ['Willem van Bergen', 'Bart ten Brinke']
+  s.email    = ['willem@railsdoctors.com', 'bart@railsdoctors.com']
+  s.homepage = 'http://railsdoctors.com'
+
+  # The files and test_files directives are set automatically by the release script.
+  # Do not change them by hand, but make sure to add the files to the git repository.
+  s.files      = %w(.gitignore MIT-LICENSE README.rdoc Rakefile browser-prof.gemspec init.rb lib/browser-prof.rb lib/ruby-prof/graph_html_printer_enhanced.rb lib/ruby-prof/template.rhtml pkg/browser_profiler-1.2.0.gem tasks/github-gem.rake test/functional/slow_controller_test.rb test/test_helper.rb)
+  s.test_files = %w(test/functional/slow_controller_test.rb)
+end

data/init.rb

@@ -0,0 +1,7 @@
+class ActiveRecord::Base
+  def self.inspect
+    "#<#{name}#>"
+  end
+end
+
+require 'browser-prof'

data/lib/browser-prof.rb

@@ -0,0 +1,37 @@
+module ActionController
+  class Base
+    def process_with_browser_profiling(request, response, method = :perform_action, *arguments)
+      browser_output = request.parameters.key?('browser_profile!') || request.parameters[:params].key?('browser_profile!') || ENV["BROWSER_PROFILE"]
+      file_output = request.parameters.key?('file_profile') || request.parameters[:params].key?('file_profile!') || ENV["FILE_PROFILE"]
+
+      if (browser_output or file_output)
+        # Only require these files in needed
+        require 'ruby-prof'
+        require 'ruby-prof/graph_html_printer_enhanced'
+
+        #run the process through a profile block
+        profile_results = RubyProf.profile {
+          response = process_without_browser_profiling(request,response, method, *arguments);
+        }
+
+        #Use the enhanced html printer to get better results
+        printer = RubyProf::GraphHtmlPrinterEnhanced.new(profile_results)
+
+        #determine output location
+        if file_output
+          printer.print(File.new("#{RAILS_ROOT}/log/profile_out.html","w"))
+        else
+          response.body << printer.print("",0)
+        end
+
+        #reset the content length so the profiling data is included in the response
+        response.send("set_content_length!")
+
+        response
+      else
+        process_without_browser_profiling(request, response, method, *arguments)
+      end
+    end
+    alias_method_chain :process, :browser_profiling
+  end
+end

data/lib/ruby-prof/graph_html_printer_enhanced.rb

@@ -0,0 +1,123 @@
+# This is a modified version from the rubyprof project rubyprof.rubyforge.org
+require 'ruby-prof/abstract_printer'
+require "erb"
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_html.html] profile reports as html. 
+  # To use the grap html printer:
+  #
+	# 	result = RubyProf.profile do
+  #			[code to profile]
+  #		end
+  #
+  # 	printer = RubyProf::GraphHtmlPrinter.new(result, 5)
+  # 	printer.print(STDOUT, 0)
+  #
+  # The constructor takes two arguments.  The first is
+  # a RubyProf::Result object generated from a profiling
+  # run.  The second is the minimum %total (the methods 
+  # total time divided by the overall total time) that
+  # a method must take for it to be printed out in 
+  # the report.  Use this parameter to eliminate methods
+  # that are not important to the overall profiling results.
+	#  
+	#  This is mostly from ruby_forge, with some optimization changes.
+  
+  class GraphHtmlPrinterEnhanced < AbstractPrinter
+  include ERB::Util
+    
+    MIN_TIME = 0.01
+    MIN_THREAD_TIME = 0.0
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 10
+    CALL_WIDTH = 20
+  
+    # Create a GraphPrinter.  Result is a RubyProf::Result  
+    # object generated from a profiling run.
+    def initialize(result)
+      super(result)
+      @thread_times = Hash.new
+      calculate_thread_times
+    end
+
+    # Print a graph html report to the provided output.
+    # 
+    # output - Any IO oject, including STDOUT or a file. 
+    # The default value is STDOUT.
+    # 
+    # options - Hash of print options.  See #setup_options 
+    #           for more information.
+    #
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      
+      _erbout = @output
+      erb = ERB.new(template, nil, nil)
+      @output << erb.result(binding)
+    end
+
+    # These methods should be private but then ERB doesn't
+    # work.  Turn off RDOC though 
+    #--
+    def calculate_thread_times
+      # Cache thread times since this is an expensive
+      # operation with the required sorting      
+      @result.threads.each do |thread_id, methods|
+        top = methods.sort.last
+        
+        thread_time = 0.01
+        thread_time = top.total_time if top.total_time > 0
+
+        @thread_times[thread_id] = thread_time 
+      end
+    end
+    
+    def thread_time(thread_id)
+      @thread_times[thread_id]
+    end
+
+    def select_methods(methods)
+      return [] unless methods
+      methods.select {|method| method.total_time >= MIN_TIME }
+    end
+
+    def select_threads(threads)
+      threads.select {|thread_id, methods| thread_time(thread_id) >= MIN_THREAD_TIME }
+    end
+   
+    def total_percent(thread_id, method)
+      overall_time = self.thread_time(thread_id)
+      (method.total_time/overall_time) * 100
+    end
+    
+    def self_percent(method)
+      overall_time = self.thread_time(method.thread_id)
+      (method.self_time/overall_time) * 100
+    end
+
+    # Creates a link to a method.  Note that we do not create
+    # links to methods which are under the min_perecent 
+    # specified by the user, since they will not be
+    # printed out.
+    def create_link(thread_id, method)
+      if self.total_percent(thread_id, method) < min_percent
+        # Just return name
+        h method.full_name
+      else
+        href = '#' + method_href(thread_id, method)
+        "<a href=\"#{href}\">#{h method.full_name}</a>" 
+      end
+    end
+    
+    def method_href(thread_id, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread_id.to_s)
+    end
+    
+    def template
+      return IO.read(File.dirname(__FILE__) + "/template.rhtml")
+    end
+ 
+  end
+end	
+

data/lib/ruby-prof/template.rhtml

@@ -0,0 +1,156 @@
+<style media="all" type="text/css">
+	table {
+		border-collapse: collapse;
+		border: 1px solid #CCC;
+		font-family: Verdana, Arial, Helvetica, sans-serif;
+		font-size: 9pt;
+		line-height: normal;
+		width: 900px;
+	}
+
+	th {
+		text-align: center;
+		border-top: 1px solid #FB7A31;
+		border-bottom: 1px solid #FB7A31;
+		background: #FFC;
+		padding: 0.3em;
+		border-left: 1px solid silver;
+	}
+
+	tr.break td {
+		border: 0;
+		border-top: 1px solid #FB7A31;
+		padding: 0;
+		margin: 0;
+	}
+
+	tr.method td {
+		font-weight: bold;
+	}
+	td.method_name {
+		width: 200px;
+	}
+
+	td {
+		padding: 0.3em;
+	}
+
+	td:first-child {
+		width: 190px;
+	}
+
+	td {
+		border-left: 1px solid #CCC;
+		text-align: center;
+	}
+	#browser_profile {
+		width: 920px;
+		margin: 0 auto;
+	}
+
+</style>
+<div id="browser_profile">
+	<h1>Profile Report</h1>
+	<br/><br/>
+	<table>
+		<tr><th>Column</th><th>Description</th></tr>
+		<tr><td>%self</td><td>The percentage of time spent in this method, derived from self_time/total_time</td></tr>
+		<tr><td>cumulative</td><td>The sum of the time spent in this method and all the methods listed above it.</td></tr>
+		<tr><td>total</td><td>The time spent in this method and its children.</td></tr>
+		<tr><td>self</td><td>The time spent in this method.</td></tr>
+		<tr><td>children</td><td>The time spent in this method's children.</td></tr>
+		<tr><td>calls</td><td>The number of times this method was called.</td></tr>
+		<tr><td>self/call</td><td>The average time spent per call in this method.</td></tr>
+		<tr><td>total/call</td><td>The average time spent per call in this method and its children.</td></tr>
+		<tr><td>name</td><td>The name of the method.</td></tr>
+	</table>
+	<br/><br/>
+	<!-- Threads Table -->
+    <table>
+      <tr>
+        <th>Thread ID</th>
+        <th>Total Time</th>
+      </tr>
+      <% for thread_id, methods in @result.threads %>
+      <tr>
+        <td><a href="#<%= thread_id %>"><%= thread_id %></a></td>
+        <td><%= thread_time(thread_id) %></td>
+      </tr>
+      <% end %>
+    </table>
+
+    <!-- Methods Tables -->
+    <% for thread_id, methods in @result.threads
+         total_time = thread_time(thread_id) %>
+      <h2><a name="<%= thread_id %>">Thread <%= thread_id %></a></h2>
+
+      <table>
+        <tr>
+          <th><%= sprintf("%#{PERCENTAGE_WIDTH}s", "%Total") %></th>
+          <th><%= sprintf("%#{PERCENTAGE_WIDTH}s", "%Self") %></th>
+          <th><%= sprintf("%#{TIME_WIDTH}s", "Total") %></th>
+          <th><%= sprintf("%#{TIME_WIDTH}s", "Self") %></th>
+          <th><%= sprintf("%#{TIME_WIDTH}s", "Wait") %></th>
+          <th><%= sprintf("%#{TIME_WIDTH+2}s", "Child") %></th>
+          <th><%= sprintf("%#{CALL_WIDTH}s", "Calls") %></th>
+          <th>Name</th>
+          <th>Line</th>
+        </tr>
+
+        <% select_methods(methods).sort.reverse_each do |method|
+            total_percentage = (method.total_time/total_time) * 100
+            next if total_percentage < min_percent
+            self_percentage = (method.self_time/total_time) * 100
+            %>
+
+            <!-- Parents -->
+            <% for caller in select_methods(method.aggregate_parents) %>
+              <tr>
+                <td>&nbsp;</td>
+                <td>&nbsp;</td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.total_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.self_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.wait_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.children_time) %></td>
+                <% called = "#{caller.called}/#{method.called}" %>
+                <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                <td><%= create_link(thread_id, caller.target) %></td>
+                <td><a href="file://<%= File.expand_path(caller.target.source_file) %>#line=<%= caller.line %>"><%= caller.line %></a></td>
+              </tr>
+            <% end %>
+
+            <tr class="method">
+              <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage) %></td>
+              <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage) %></td>
+              <td><%= sprintf("%#{TIME_WIDTH}.2f", method.total_time) %></td>
+              <td><%= sprintf("%#{TIME_WIDTH}.2f", method.self_time) %></td>
+              <td><%= sprintf("%#{TIME_WIDTH}.2f", method.wait_time) %></td>
+              <td><%= sprintf("%#{TIME_WIDTH}.2f", method.children_time) %></td>
+              <td><%= sprintf("%#{CALL_WIDTH}i", method.called) %></td>
+              <td><a name="<%= method_href(thread_id, method) %>"><%= h method.full_name %></a></td>
+              <td><a href="file://<%= File.expand_path(method.source_file) %>#line=<%= method.line %>"><%= method.line %></a></td>
+            </tr>
+
+            <!-- Children -->
+            <% for callee in select_methods(method.children) %>
+              <tr>
+                <td>&nbsp;</td>
+                <td>&nbsp;</td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.total_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.self_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.wait_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.children_time) %></td>
+                <% called = "#{callee.called}/#{callee.target.called}" %>
+                <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                <td><%= create_link(thread_id, callee.target) %></td>
+                <td><a href="file://<%= File.expand_path(method.source_file) %>#line=<%= callee.line %>"><%= callee.line %></a></td>
+              </tr>
+            <% end %>
+            <!-- Create divider row -->
+            <tr class="break"><td colspan="8"></td></tr>
+        <% end %>
+      </table>
+
+	<% end %>
+</div>
+

data/tasks/github-gem.rake

@@ -0,0 +1,365 @@
+require 'rubygems'
+require 'rake'
+require 'rake/tasklib'
+require 'date'
+require 'set'
+
+module GithubGem
+
+  # Detects the gemspc file of this project using heuristics.
+  def self.detect_gemspec_file
+    FileList['*.gemspec'].first
+  end
+
+  # Detects the main include file of this project using heuristics
+  def self.detect_main_include
+    if detect_gemspec_file =~ /^(\.*)\.gemspec$/ && File.exist?("lib/#{$1}.rb")
+      "lib/#{$1}.rb"
+    elsif FileList['lib/*.rb'].length == 1
+      FileList['lib/*.rb'].first
+    else
+      nil
+    end
+  end
+
+  class RakeTasks
+
+    attr_reader   :gemspec, :modified_files
+    attr_accessor :gemspec_file, :task_namespace, :main_include, :root_dir, :spec_pattern, :test_pattern, :remote, :remote_branch, :local_branch
+
+    # Initializes the settings, yields itself for configuration
+    # and defines the rake tasks based on the gemspec file.
+    def initialize(task_namespace = :gem)
+      @gemspec_file   = GithubGem.detect_gemspec_file
+      @task_namespace = task_namespace
+      @main_include   = GithubGem.detect_main_include
+      @modified_files = Set.new
+      @root_dir       = Dir.pwd
+      @test_pattern   = 'test/**/*_test.rb'
+      @spec_pattern   = 'spec/**/*_spec.rb'
+      @local_branch   = 'master'
+      @remote         = 'origin'
+      @remote_branch  = 'master'
+
+      yield(self) if block_given?
+
+      load_gemspec!
+      define_tasks!
+    end
+
+    protected
+
+    def git
+      @git ||= ENV['GIT'] || 'git'
+    end
+
+    # Define Unit test tasks
+    def define_test_tasks!
+      require 'rake/testtask'
+
+      namespace(:test) do
+        Rake::TestTask.new(:basic) do |t|
+          t.pattern = test_pattern
+          t.verbose = true
+          t.libs << 'test'
+        end
+      end
+
+      desc "Run all unit tests for #{gemspec.name}"
+      task(:test => ['test:basic'])
+    end
+
+    # Defines RSpec tasks
+    def define_rspec_tasks!
+      require 'rspec/core/rake_task'
+
+      namespace(:spec) do
+        desc "Verify all RSpec examples for #{gemspec.name}"
+        RSpec::Core::RakeTask.new(:basic) do |t|
+          t.pattern = spec_pattern
+        end
+
+        desc "Verify all RSpec examples for #{gemspec.name} and output specdoc"
+        RSpec::Core::RakeTask.new(:specdoc) do |t|
+          t.pattern = spec_pattern
+          t.rspec_opts = ['--format', 'documentation', '--color']
+        end
+
+        desc "Run RCov on specs for #{gemspec.name}"
+        RSpec::Core::RakeTask.new(:rcov) do |t|
+          t.pattern = spec_pattern
+          t.rcov = true
+          t.rcov_opts = ['--exclude', '"spec/*,gems/*"', '--rails']
+        end
+      end
+
+      desc "Verify all RSpec examples for #{gemspec.name} and output specdoc"
+      task(:spec => ['spec:specdoc'])
+    end
+
+    # Defines the rake tasks
+    def define_tasks!
+
+      define_test_tasks!  if has_tests?
+      define_rspec_tasks! if has_specs?
+
+      namespace(@task_namespace) do
+        desc "Updates the filelist in the gemspec file"
+        task(:manifest) { manifest_task }
+
+        desc "Builds the .gem package"
+        task(:build => :manifest) { build_task }
+
+        desc "Sets the version of the gem in the gemspec"
+        task(:set_version => [:check_version, :check_current_branch]) { version_task }
+        task(:check_version => :fetch_origin) { check_version_task }
+
+        task(:fetch_origin) { fetch_origin_task }
+        task(:check_current_branch) { check_current_branch_task }
+        task(:check_clean_status) { check_clean_status_task }
+        task(:check_not_diverged => :fetch_origin) { check_not_diverged_task }
+
+        checks = [:check_current_branch, :check_clean_status, :check_not_diverged, :check_version]
+        checks.unshift('spec:basic') if has_specs?
+        checks.unshift('test:basic') if has_tests?
+        # checks.push << [:check_rubyforge] if gemspec.rubyforge_project
+
+        desc "Perform all checks that would occur before a release"
+        task(:release_checks => checks)
+
+        release_tasks = [:release_checks, :set_version, :build, :github_release, :gemcutter_release]
+        # release_tasks << [:rubyforge_release] if gemspec.rubyforge_project
+
+        desc "Release a new version of the gem using the VERSION environment variable"
+        task(:release => release_tasks) { release_task }
+        
+        namespace(:release) do
+          desc "Release the next version of the gem, by incrementing the last version segment by 1"
+          task(:next => [:next_version] + release_tasks) { release_task }
+
+          desc "Release the next version of the gem, using a patch increment (0.0.1)"
+          task(:patch => [:next_patch_version] + release_tasks) { release_task }
+
+          desc "Release the next version of the gem, using a minor increment (0.1.0)"
+          task(:minor => [:next_minor_version] + release_tasks) { release_task }
+
+          desc "Release the next version of the gem, using a major increment (1.0.0)"
+          task(:major => [:next_major_version] + release_tasks) { release_task }
+        end
+
+        # task(:check_rubyforge)   { check_rubyforge_task }
+        # task(:rubyforge_release) { rubyforge_release_task }
+        task(:gemcutter_release) { gemcutter_release_task }
+        task(:github_release => [:commit_modified_files, :tag_version]) { github_release_task }
+        task(:tag_version) { tag_version_task }
+        task(:commit_modified_files) { commit_modified_files_task }
+
+        task(:next_version)       { next_version_task }
+        task(:next_patch_version)  { next_version_task(:patch) }
+        task(:next_minor_version) { next_version_task(:minor) }
+        task(:next_major_version) { next_version_task(:major) }
+        
+        desc "Updates the gem release tasks with the latest version on Github"
+        task(:update_tasks) { update_tasks_task }
+      end
+    end
+
+    # Updates the files list and test_files list in the gemspec file using the list of files
+    # in the repository and the spec/test file pattern.
+    def manifest_task
+      # Load all the gem's files using "git ls-files"
+      repository_files = `#{git} ls-files`.split("\n")
+      test_files       = Dir[test_pattern] + Dir[spec_pattern]
+
+      update_gemspec(:files, repository_files)
+      update_gemspec(:test_files, repository_files & test_files)
+    end
+
+    # Builds the gem
+    def build_task
+      sh "gem build -q #{gemspec_file}"
+      Dir.mkdir('pkg') unless File.exist?('pkg')
+      sh "mv #{gemspec.name}-#{gemspec.version}.gem pkg/#{gemspec.name}-#{gemspec.version}.gem"
+    end
+
+    def newest_version
+      `#{git} tag`.split("\n").map { |tag| tag.split('-').last }.compact.map { |v| Gem::Version.new(v) }.max || Gem::Version.new('0.0.0')
+    end
+
+    def next_version(increment = nil)
+      next_version = newest_version.segments
+      increment_index = case increment
+        when :micro then 3
+        when :patch then 2
+        when :minor then 1
+        when :major then 0
+        else next_version.length - 1
+      end
+      
+      next_version[increment_index] ||= 0
+      next_version[increment_index] = next_version[increment_index].succ
+      ((increment_index + 1)...next_version.length).each { |i| next_version[i] = 0 }
+      
+      Gem::Version.new(next_version.join('.'))
+    end
+
+    def next_version_task(increment = nil)
+      ENV['VERSION'] = next_version(increment).version
+      puts "Releasing version #{ENV['VERSION']}..."
+    end
+
+    # Updates the version number in the gemspec file, the VERSION constant in the main
+    # include file and the contents of the VERSION file.
+    def version_task
+      update_gemspec(:version, ENV['VERSION']) if ENV['VERSION']
+      update_gemspec(:date, Date.today)
+
+      update_version_file(gemspec.version)
+      update_version_constant(gemspec.version)
+    end
+
+    def check_version_task
+      raise "#{ENV['VERSION']} is not a valid version number!" if ENV['VERSION'] && !Gem::Version.correct?(ENV['VERSION'])
+      proposed_version = Gem::Version.new((ENV['VERSION'] || gemspec.version).dup)
+      raise "This version (#{proposed_version}) is not higher than the highest tagged version (#{newest_version})" if newest_version >= proposed_version
+    end
+
+    # Checks whether the current branch is not diverged from the remote branch
+    def check_not_diverged_task
+      raise "The current branch is diverged from the remote branch!" if `#{git} rev-list HEAD..#{remote}/#{remote_branch}`.split("\n").any?
+    end
+
+    # Checks whether the repository status ic clean
+    def check_clean_status_task
+      raise "The current working copy contains modifications" if `#{git} ls-files -m`.split("\n").any?
+    end
+
+    # Checks whether the current branch is correct
+    def check_current_branch_task
+      raise "Currently not on #{local_branch} branch!" unless `#{git} branch`.split("\n").detect { |b| /^\* / =~ b } == "* #{local_branch}"
+    end
+
+    # Fetches the latest updates from Github
+    def fetch_origin_task
+      sh git, 'fetch', remote
+    end
+
+    # Commits every file that has been changed by the release task.
+    def commit_modified_files_task
+      really_modified = `#{git} ls-files -m #{modified_files.entries.join(' ')}`.split("\n")
+      if really_modified.any?
+        really_modified.each { |file| sh git, 'add', file }
+        sh git, 'commit', '-m', "Released #{gemspec.name} gem version #{gemspec.version}."
+      end
+    end
+
+    # Adds a tag for the released version
+    def tag_version_task
+      sh git, 'tag', '-a', "#{gemspec.name}-#{gemspec.version}", '-m', "Released #{gemspec.name} gem version #{gemspec.version}."
+    end
+
+    # Pushes the changes and tag to github
+    def github_release_task
+      sh git, 'push', '--tags', remote, remote_branch
+    end
+
+    def gemcutter_release_task
+      sh "gem", 'push', "pkg/#{gemspec.name}-#{gemspec.version}.gem"
+    end
+
+    # Gem release task.
+    # All work is done by the task's dependencies, so just display a release completed message.
+    def release_task
+      puts
+      puts "Release successful."
+    end
+
+    private
+
+    # Checks whether this project has any RSpec files
+    def has_specs?
+      FileList[spec_pattern].any?
+    end
+
+    # Checks whether this project has any unit test files
+    def has_tests?
+      FileList[test_pattern].any?
+    end
+
+    # Loads the gemspec file
+    def load_gemspec!
+      @gemspec = eval(File.read(@gemspec_file))
+    end
+
+    # Updates the VERSION file with the new version
+    def update_version_file(version)
+      if File.exists?('VERSION')
+        File.open('VERSION', 'w') { |f| f << version.to_s }
+        modified_files << 'VERSION'
+      end
+    end
+
+    # Updates the VERSION constant in the main include file if it exists
+    def update_version_constant(version)
+      if main_include && File.exist?(main_include)
+        file_contents = File.read(main_include)
+        if file_contents.sub!(/^(\s+VERSION\s*=\s*)[^\s].*$/) { $1 + version.to_s.inspect }
+          File.open(main_include, 'w') { |f| f << file_contents }
+          modified_files << main_include
+        end
+      end
+    end
+
+    # Updates an attribute of the gemspec file.
+    # This function will open the file, and search/replace the attribute using a regular expression.
+    def update_gemspec(attribute, new_value, literal = false)
+
+      unless literal
+        new_value = case new_value
+          when Array        then "%w(#{new_value.join(' ')})"
+          when Hash, String then new_value.inspect
+          when Date         then new_value.strftime('%Y-%m-%d').inspect
+          else              raise "Cannot write value #{new_value.inspect} to gemspec file!"
+        end
+      end
+
+      spec   = File.read(gemspec_file)
+      regexp = Regexp.new('^(\s+\w+\.' + Regexp.quote(attribute.to_s) + '\s*=\s*)[^\s].*$')
+      if spec.sub!(regexp) { $1 + new_value }
+        File.open(gemspec_file, 'w') { |f| f << spec }
+        modified_files << gemspec_file
+
+        # Reload the gemspec so the changes are incorporated
+        load_gemspec!
+        
+        # Also mark the Gemfile.lock file as changed because of the new version.
+        modified_files << 'Gemfile.lock' if File.exist?(File.join(root_dir, 'Gemfile.lock'))
+      end
+    end
+
+    # Updates the tasks file using the latest file found on Github
+    def update_tasks_task
+      require 'net/https'
+      require 'uri'
+      
+      uri = URI.parse('https://github.com/wvanbergen/github-gem/raw/master/tasks/github-gem.rake')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      response = http.request(Net::HTTP::Get.new(uri.path))
+
+      if Net::HTTPSuccess === response
+        open(__FILE__, "w") { |file| file.write(response.body) }
+        relative_file = File.expand_path(__FILE__).sub(%r[^#{@root_dir}/], '')
+        if `#{git} ls-files -m #{relative_file}`.split("\n").any?
+          sh git, 'add', relative_file
+          sh git, 'commit', '-m', "Updated to latest gem release management tasks."
+        else
+          puts "Release managament tasks already are at the latest version."
+        end
+      else
+        raise "Download failed with HTTP status #{response.code}!"
+      end
+    end
+  end
+end

data/test/functional/slow_controller_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class SlowControllerTest <  ActionController::TestCase
+	test "should profile" do
+		get :profile_me, :params => {}
+		assert_response :success
+		assert_equal "slow action", @response.body
+	end
+
+	test "should have mixin" do
+	  assert @controller.respond_to?(:process_with_browser_profiling)
+	end
+
+	test "should profile param adds profile" do
+		get :profile_me, :params => {"browser_profile!" => ""}
+		assert_response :success
+
+		assert profiled?(@response.body)
+	end
+
+	test "should output to file" do
+		clean_outfile
+
+		get :profile_me, :params => {"file_profile!" => ""}
+		assert_response :success
+
+		assert ! profiled?(@response.body)
+		assert File.exists?(profile_out_file)
+		assert profiled?(File.read(profile_out_file))
+
+		clean_outfile
+	end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+# Bootstrap rails
+ENV["RAILS_ENV"] = "test"
+rails_path = File.expand_path(File.dirname(__FILE__) + "/../rails_test/config/environment.rb")
+
+unless File.exists?(rails_path)
+  p 'Rails not found, please run:'
+  p '$ rails rails_test'
+  exit
+end
+require rails_path
+
+require 'test_help'
+require 'pp'
+require File.expand_path(File.dirname(__FILE__) +'/../init.rb') # Load browser=prof into rails_env
+
+class SlowController < ActionController::Base
+	def profile_me
+		sleep 1
+		render :text => "slow action"
+	end
+end
+
+# Helpers
+def clean_outfile
+	FileUtils.rm_rf(profile_out_file)
+end
+
+def profiled?(body)
+	(body =~ /browser_profile/) && (body =~ /Profile Report/)
+end
+
+def profile_out_file
+	"#{RAILS_ROOT}/log/profile_out.html"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: browser-prof
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 1
+  - 2
+  - 3
+  version: 1.2.3
+platform: ruby
+authors: 
+- Willem van Bergen
+- Bart ten Brinke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-prof
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: "    This is a simple tool to profile single web requests in Rails using the power or ruby-prof.\n"
+email: 
+- willem@railsdoctors.com
+- bart@railsdoctors.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- browser-prof.gemspec
+- init.rb
+- lib/browser-prof.rb
+- lib/ruby-prof/graph_html_printer_enhanced.rb
+- lib/ruby-prof/template.rhtml
+- pkg/browser_profiler-1.2.0.gem
+- tasks/github-gem.rake
+- test/functional/slow_controller_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://railsdoctors.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- browser-prof
+- --main
+- README.rdoc
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- ruby-prof gem is required.
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rails tool to to profile single requests using ruby-prof.
+test_files: 
+- test/functional/slow_controller_test.rb