pilfer 0.0.1.pre4 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzFkODBmMDU3MzMxMmQ2MGRiYjZhMmI2Y2I2OWQ4NmE0YzVlMmJiOQ==
+    MWJkZjU3Njk0N2IyMjZiNjJiOTZkMTQ4ZDk4MGQwZWU3MGQ4NGExNQ==
   data.tar.gz: !binary |-
-    ZjVlOGMyYWFiNjM5ZWIyODI5NGU5MDI3YWYxZmJmNGM3YzFlNWQ4Nw==
+    NmExMWFlYWIwNGU3ZTg5NTk1MWYyMTgxZWJhMmQwNDVhOWIwMDdiMw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NTI5NjVlNGNlNGU0NzlkNzgwYWI0YTYyMjhmNmMzYWQyOWQwOWFkYmJiN2Ey
-    NTY4NWUxOTRkOTRjNjlhZjA3ZmEwNWFmOWQ2YmRlYjhmNjEyNjJiMDg2OWY2
-    NTA0MTZhYWI3YzYzOWE5OWZkODRmMWI4MGI3MjhkYjEwYzk0NGU=
+    YWM2ZTNjNmZkYzA5YzlhNDIxM2RiYTA5NTkwOTZkN2VkODBkOGEwN2VmMmM1
+    ZjdiYjRjNzhkZWEzYzlmN2MzNmZhZTRiYjUxZjc0NWE2Y2UwMDAwYmViMTgw
+    ZjE1NDg3MzM0NzMyMGVjM2NiMGU4OGIxZjU0YTcxMDlhM2Y4NTY=
   data.tar.gz: !binary |-
-    YzY3Mzk5N2VlNzBiNzdmMWU2ZDBhNDMxMGEwNDVhODQwMTI1MTRhMWQxODJk
-    OGM1MDIzYjVlYTVkYTFkYTU5MjMwNzE2ZDA5YjkxNzEzZWU5OWYwYzc5OTU3
-    OWVhZmQ0YTc5NGNmNTY3MWU0Zjk0ZDc1NDA5ZmVmODg0ZmE4YTU=
+    M2RhZDQ5MWFmMmNkYjI5MTM5NzM4ODA1NTFiODUxOTZhMWU5MWYwMmY5YjE0
+    NjA5OTE3ZDVlZmUzNWY3NDBhYjkzZmY0Y2NmMTBlYmMwMDY3ZTBiYjlmYmE3
+    NTVmNGZiOWE1NWFkYzBjMjQ4ZjFhMGViNDM2ODBiZTY1YjYxZWY=

data/README.md

@@ -1,30 +1,94 @@
 # Pilfer
 
-Look into your ruby with [rblineprof](https://github.com/tmm1/rblineprof/).
+Profile Ruby code and find out _exactly_ how slow it runs.
+
+Pilfer uses [rblineprof][] to measure how long each line of code takes to
+execute and the number of times it was called.
+
+![Pilfer Profile.png](http://cl.ly/image/2a1d332M2w05/Pilfer%20Profile.png)
+
+Take a look at some [Pilfer profiles of the Bundler API site][bundler-pilfer].
+
+## Installation
+
+Using with Bundler is as simple as adding `pilfer` to your `Gemfile`.
+
+```ruby
+gem 'pilfer', '~> 1.0.0'
+```
+
+Or install it locally like any other gem.
+
+```bash
+$ gem install pilfer
+```
 
 ## Usage
 
 Profile a block of code saving the report to the file `profile.log`.
 
+```ruby
+require 'pilfer'
+
+reporter = Pilfer::Logger.new('pilfer.log')
+profiler = Pilfer::Profiler.new(reporter)
+profiler.profile('bubble sorting') do
+  array = (0..100).to_a.shuffle
+  bubble_sort array
+end
+```
+
+Profile your Rack or Rails app using `Pilfer::Middleware`.
+
 ```ruby
 reporter = Pilfer::Logger.new('pilfer.log')
 profiler = Pilfer::Profiler.new(reporter)
-profiler.profile { do_something }
+use Pilfer::Middleware :profiler => profiler
 ```
 
-The report prints the source of each line of code executed and includes the
-total execution time and the number of times the line was executed.
+The profile report consists of the wall time and call count for each line of
+code executed along with the total wall and CPU times for each file.
 
-_TODO: Show profile response._
+```
+Profile start="2013-05-12 00:41:16 UTC" description="bubble sorting"
+/Users/Larry/Sites/pilfer/sort.rb wall_time=42.5ms cpu_time=29.7ms
+                   | require 'pilfer'
+                   |
+                   | def bubble_sort(container)
+    42.5ms (    1) |   loop do
+                   |     swapped = false
+    42.3ms (   94) |     (container.size-1).times do |i|
+    10.2ms ( 9400) |       if (container[i] <=> container[i+1]) == 1
+     6.2ms ( 5092) |         container[i], container[i+1] = container[i+1], container[i] # Swap
+                   |         swapped = true
+                   |       end
+                   |     end
+                   |     break unless swapped
+                   |   end
+                   |   container
+                   | end
+                   |
+                   | reporter = Pilfer::Logger.new($stdout)
+                   | profiler = Pilfer::Profiler.new(reporter)
+                   | profiler.profile_files_matching(/sort\.rb/, 'bubble sorting') do
+     0.1ms (    3) |   array = (0..100).to_a.shuffle
+    42.5ms (    1) |   bubble_sort array
+                   | end
+```
 
 ### Step 1: Create a reporter
 
-Profiles can be sent to a [pilfer-server][] or written to a file or `IO`
-object.
+Decide how you want line profiles to be reported. Profiles can be sent to a
+[pilfer-server][] or written to a file path or `IO` object.
 
 ```ruby
-reporter = Pilfer::Server.new('https://pilfer.com', 'abc123')
+# Send reports to a pilfer-server
+reporter = Pilfer::Server.new('https://pilfer.com', 'my-pilfer-server-token')
+
+# Append reports to a file
 reporter = Pilfer::Logger.new('pilfer.log')
+
+# Print reports to standard out
 reporter = Pilfer::Logger.new($stdout)
 ```
 
@@ -33,12 +97,21 @@ the application root with `:app_root` to have it trimmed from reported file
 paths.
 
 ```ruby
-reporter = Pilfer::Logger.new($stdout, :app_root => '/my/app')
+reporter = Pilfer::Logger.new('pilfer.log')
+# Profile start=2013-05-02 14:17:26 UTC
+# /Sites/bundler-api/lib/bundler-api/web.rb wall_time=1009.5ms cpu_time=0.5ms
+# ...
+
+reporter = Pilfer::Logger.new('pilfer.log', :app_root => '/Sites/bundler-api/')
+# Profile start=2013-05-02 14:17:26 UTC
+# lib/bundler-api/web.rb wall_time=1009.5ms cpu_time=0.5ms
+# ...
 ```
 
 ### Step 2: Create a profiler
 
-Pass the reporter to a new `Pilfer::Profiler`.
+A `Profiler` runs the line profiler and sends it to a reporter. Create one
+passing the reporter created in the previous step.
 
 ```ruby
 profiler = Pilfer::Profiler.new(reporter)
@@ -46,53 +119,81 @@ profiler = Pilfer::Profiler.new(reporter)
 
 ### Step 3: Profile a block of code
 
-Profile a block of code with `#profile`.
+Use `Profiler#profile` to profile a block of code. Optionally, provide a
+description of the code being profiling.
 
 ```ruby
-profiler.profile { do_something }
+profiler.profile('bubble sorting') do
+  array = (0..100).to_a.shuffle
+  bubble_sort array
+end
 ```
 
-Every file that's executed by the block--including code outside the
-application like gems and standard libraries--will be included in the profile.
-Use `#profile_files_matching` and provide a regular expression to limit
-profiling to only matching file paths.
+Every file that's executed by the block including code outside the
+application like gems and standard libraries will be included in the profile.
+Use `#profile_files_matching` to limit profiling to files whose paths match a
+regular expression.
 
 ```ruby
+# Only profile Rails models
 matcher = %r{^#{Regexp.escape(Rails.root.to_s)}/app/models}
-profiler.profile_files_matching(matcher) { do_something }
+profiler.profile_files_matching(matcher, 'User.find_by_email') do
+  User.find_by_email('arthur@dent.com')
+end
+```
+
+Additional arguments to `#profile` and `#profile_files_matching` will be
+passed to the reporter. The `Pilfer::Server` reporter, for example, can submit
+profiles asynchronously.
+
+```ruby
+profiler.profile('bubble sorting', :submit => :async) do
+  array = (0..100).to_a.shuffle
+  bubble_sort array
+end
 ```
 
-## Pilfer Server
+## Extras
 
-[pilfer-server][] is your own, personal service for collecting and viewing
-profile reports. Follow the [pilfer-server setup instructions][pilfer-server]
-to stand up a new server and send it reports using its URL and token.
+### Pilfer Server
+
+[Pilfer Server][pilfer-server] is your own, personal service for collecting
+and viewing line profiles gathered by Pilfer. Follow the
+[Pilfer Server setup instructions][pilfer-server-readme] to stand up a new
+server.
 
 ```ruby
-reporter = Pilfer::Server.new('https://pilfer.com', 'abc123')
+reporter = Pilfer::Server.new('https://pilfer.com', 'my-pilfer-server-token')
+profiler = Pilfer::Profiler.new(reporter)
+profiler.profile('bubble sorting') do
+  array = (0..100).to_a.shuffle
+  bubble_sort array
+end
 ```
 
-## Rack Middleware
+### Rack Middleware
 
-Profile your Rack or Rails app using `Pilfer::Middleware`.
+Profile your entire Rack or Rails app using `Pilfer::Middleware`. Pass it a
+`Profiler` created with a reporter as normal.
 
 ```ruby
-reporter = Pilfer::Logger.new($stdout, :app_root => Rails.root)
+reporter = Pilfer::Server.new('https://pilfer.com', 'my-pilfer-server-token')
 profiler = Pilfer::Profiler.new(reporter)
 use Pilfer::Middleware :profiler => profiler
 ```
 
-Restrict the files profiled by passing a regular expression with
-`:files_matching`.
+Restrict profiling to files matching a regular expression using the
+`:files_matching` option. This calls `Profiler#profile_files_matching` using
+the given regular expression.
 
 ```ruby
 matcher = %r{^#{Regexp.escape(Rails.root.to_s)}/(app|config|lib|vendor/plugin)}
-use Pilfer::Middleware, :files_matching => matcher,
-                        :profiler       => profiler
+use Pilfer::Middleware, :profiler       => profiler,
+                        :files_matching => matcher
 ```
 
-You probably don't want to profile _every_ request. The given block will be
-evaluated on each request to determine if a profile should be run.
+You almost certainly don't want to profile _every_ request. Provide a block to
+determine if a profile should be run on the incoming request.
 
 ```ruby
 use Pilfer::Middleware, :profiler => profiler do
@@ -104,10 +205,39 @@ end
 The Rack environment is available to allow profiling on demand.
 
 ```ruby
+# Profile requests containing the query string ?profile=true
 use Pilfer::Middleware, :profiler => profiler do |env|
   env.query_string.include? 'profile=true'
 end
+
+# Profile requests containing a header whose value matches a secret
+use Pilfer::Middleware, :profiler => profiler do |env|
+  env['HTTP_PROFILE_AUTHORIZATION'] == 'super-secret'
+end
 ```
 
+## Supported Ruby Versions
+
+This library is [tested against][travis] the following Ruby versions.
+
+ - MRI 1.9.3
+ - MRI 1.8.7
+ - REE
+
+If you need a specific version supported, open and issue or send a pull
+request.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Eric Lindvall and Larry Marburger. See [LICENSE][] for
+details.
+
 
-[pilfer-server]: https://github.com/eric/pilfer-server
+[rblineprof]:           https://github.com/tmm1/rblineprof
+[bundler-pilfer]:       https://pilfer.herokuapp.com/dashboard
+[pilfer-server]:        https://github.com/eric/pilfer-server
+[pilfer-server-readme]: https://github.com/eric/pilfer-server#readme
+[travis]:               https://travis-ci.org/eric/pilfer
+[license]:              LICENSE

data/lib/pilfer.rb

@@ -0,0 +1,5 @@
+require 'pilfer/logger'
+require 'pilfer/middleware'
+require 'pilfer/profiler'
+require 'pilfer/server'
+require 'pilfer/version'

data/lib/pilfer/logger.rb

@@ -13,9 +13,9 @@ module Pilfer
       end
     end
 
-    def write(profile_data, profile_start)
+    def write(profile_data, profile_start, description, options = {})
       profile = Pilfer::Profile.new(profile_data, profile_start)
-      print_report_banner profile_start
+      print_report_banner profile_start, description
       profile.each do |path, data|
         print_file_banner path, data
         print_file_source_with_profile path, data
@@ -24,9 +24,10 @@ module Pilfer
 
     private
 
-    def print_report_banner(profile_start)
+    def print_report_banner(profile_start, description)
       formatted_start = profile_start.utc.strftime('%Y-%m-%d %H:%M:%S UTC')
-      logger.info "Profile start=#{formatted_start}"
+      logger.info %{Profile start="#{formatted_start}" } +
+                    %{description="#{description}"}
     end
 
     def print_file_banner(path, data)

data/lib/pilfer/middleware.rb

@@ -14,23 +14,28 @@ module Pilfer
 
     def call(env)
       if profile_guard.call(env)
-        run_profiler { app.call(env) }
+        run_profiler(request_description(env)) { app.call(env) }
       else
         app.call(env)
       end
     end
 
-    def run_profiler(&downstream)
+    def run_profiler(description, &downstream)
       if file_matcher
-        profiler.profile_files_matching(file_matcher, &downstream)
+        profiler.profile_files_matching(file_matcher, description,
+                                        :submit => :async, &downstream)
       else
-        profiler.profile(&downstream)
+        profiler.profile(description, :submit => :async, &downstream)
       end
     end
 
     def default_profiler
-      reporter = Pilfer::Logger.new($stdout, :app_root => ENV['PWD'])
+      reporter = Pilfer::Logger.new($stdout)
       Pilfer::Profiler.new(reporter)
     end
+
+    def request_description(env)
+      "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+    end
   end
 end

data/lib/pilfer/profiler.rb

@@ -8,17 +8,19 @@ module Pilfer
       @reporter = reporter
     end
 
-    def profile(profiler = method(:lineprof), start = Time.now, &app)
-      profile_files_matching(/./, profiler, start, &app)
+    def profile(*args, &app)
+      profile_files_matching(/./, *args, &app)
     end
 
-    def profile_files_matching(matcher, profiler = method(:lineprof),
+    def profile_files_matching(matcher, description = nil,
+                               reporter_options = {},
+                               profiler = method(:lineprof),
                                start = Time.now, &app)
       app_response = nil
       profile = profiler.call(matcher) do
         app_response = app.call
       end
-      reporter.write profile, start
+      reporter.write profile, start, description, reporter_options
       app_response
     end
   end

data/lib/pilfer/server.rb

@@ -0,0 +1,103 @@
+require 'json'
+require 'net/http'
+require 'pilfer/profile'
+require 'uri'
+
+module Pilfer
+  class Server
+    attr_accessor :uri, :token
+
+    def initialize(uri, token, options = {})
+      @uri   = URI.parse(uri)
+      @token = token
+      @async = options[:async] || true
+    end
+
+    def write(profile_data, profile_start, description, options = {})
+      async   = (options[:submit] || :sync) == :async
+      details = { 'hostname'     => Socket.gethostname,
+                  'pid'          => Process.pid,
+                  'description'  => description,
+                  'file_sources' => file_sources_for_profile(profile_data) }
+
+      payload = RbLineProfFormat.
+                  profile_to_json(profile_data, profile_start).
+                  merge(details)
+
+      if async
+        Thread.new(payload) do |payload|
+          submit_profile payload
+        end
+      else
+        submit_profile payload
+      end
+    end
+
+    private
+
+    def submit_profile(payload)
+      request = Net::HTTP::Post.new('/api/profiles')
+      request.content_type = 'application/json'
+      request['Authorization'] = %{Token token="#{token}"}
+      request.body = JSON.generate(payload)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.use_ssl = true
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths
+        http.cert_store = store
+      end
+
+      case (response = http.start {|http| http.request(request) })
+      when Net::HTTPSuccess, Net::HTTPRedirection
+      else
+        response.error!
+      end
+    rescue Exception => ex
+      $stdout.puts ex.message, ex.backtrace
+    end
+
+    def file_sources_for_profile(profile_data)
+      profile_data.each_with_object({}) {|(file, _), sources|
+        sources[file] = File.exists?(file) ? File.read(file) : nil
+      }
+    end
+  end
+end
+
+# Formatting a profile as JSON may eventually be provided by rblineprof.
+class RbLineProfFormat
+  def self.profile_to_json(profile_data, profile_start)
+    files = profile_data.each_with_object({}) do |(file, lines), files|
+      profile_lines = lines[1..-1].
+                        each_with_index.
+                        each_with_object({}) do |(data, number), lines|
+        next unless data.any? {|datum| datum > 0 }
+        wall_time, cpu_time, calls = data
+        lines[number] = { 'wall_time' => wall_time,
+                          'cpu_time'  => cpu_time,
+                          'calls'     => calls }
+      end
+
+      total, child, exclusive, total_cpu, child_cpu, exclusive_cpu = lines[0]
+
+      files[file] = { 'total'         => total,
+                      'child'         => child,
+                      'exclusive'     => exclusive,
+                      'total_cpu'     => total_cpu,
+                      'child_cpu'     => child_cpu,
+                      'exclusive_cpu' => exclusive_cpu,
+                      'lines'         => profile_lines }
+    end
+
+    {
+      'profile' => {
+        'timestamp' => profile_start.to_i,
+        'files'     => files
+      }
+    }
+  end
+end

data/lib/pilfer/version.rb

@@ -1,3 +1,3 @@
 module Pilfer
-  VERSION = '0.0.1.pre4'
+  VERSION = '1.0.0'
 end

data/pilfer.gemspec

@@ -5,12 +5,16 @@ require 'pilfer/version'
 Gem::Specification.new do |spec|
   spec.name     = 'pilfer'
   spec.version  = Pilfer::VERSION
-  spec.summary  = 'Look into your ruby with rblineprof'
   spec.authors  = ['Eric Lindvall',       'Larry Marburger']
   spec.email    = ['eric@sevenscale.com', 'larry@marburger.cc']
   spec.homepage = 'https://github.com/eric/pilfer'
   spec.license  = 'MIT'
 
+  spec.summary     = 'line-profiler for ruby and rack'
+  spec.description = 'pilfer uses rblineprof to measure how long each line ' +
+                     'of code takes to execute and the number of times it '  +
+                     'was called.'
+
   spec.files = %w(Gemfile LICENSE README.md)
   spec.files << 'pilfer.gemspec'
   spec.files += Dir.glob('lib/**/*.rb')

data/spec/integration_spec.rb

@@ -0,0 +1,45 @@
+require 'helper'
+require 'stringio'
+require 'pilfer'
+
+describe Pilfer do
+  context 'reporting to a Pilfer::Logger' do
+    let(:reporter) { Pilfer::Logger.new(output) }
+    let(:output)   { StringIO.new }
+
+    it 'reports profile' do
+      Pilfer::Profiler.new(reporter).
+        profile_files_matching(/integration_spec\.rb/, "testing") do
+          10.times do
+            sleep 0.01
+          end
+        end
+
+      lines = output.string.split("\n")
+      lines[0].should =~ %r{Profile start="[\d-]{10} [\d:]{8} UTC" description="testing"$}
+
+      wall_time = lines[1].match(/wall_time=([\d\.]+)/)[1].to_f
+      wall_time.should be_within(10).of(105)
+    end
+
+    it 'ignores optional reporter args' do
+      Pilfer::Profiler.new(reporter).
+        profile_files_matching(/integration_spec\.rb/, "testing",
+                               :report => :async) do
+          10.times do
+            sleep 0.01
+          end
+        end
+
+      lines = output.string.split("\n")
+      lines[0].should =~ %r{Profile start="[\d-]{10} [\d:]{8} UTC" description="testing"$}
+
+      wall_time = lines[1].match(/wall_time=([\d\.]+)/)[1].to_f
+      wall_time.should be_within(10).of(105)
+    end
+  end
+
+  context 'reporting to a Pilfer::Server' do
+    it 'reports profile'
+  end
+end

data/spec/pilfer/logger_spec.rb

@@ -10,9 +10,10 @@ describe Pilfer::Logger do
     profile_content = File.read(profile_file).gsub('SPEC_ROOT', spec_root)
     JSON.parse(profile_content)
   }
-  let(:reporter) { StringIO.new }
-  let(:start)    { Time.at(42) }
-  let(:output) {
+  let(:description) { "GET /" }
+  let(:reporter)    { StringIO.new }
+  let(:start)       { Time.at(42) }
+  let(:output)      {
     reporter.string.each_line.map {|line|
       line.sub(/I, \[[^\]]+\]  INFO -- : /, '')
     }.join
@@ -27,7 +28,7 @@ describe Pilfer::Logger do
   describe '#write' do
     it 'writes profile to reporter' do
       expected = <<-EOS
-Profile start=1970-01-01 00:00:42 UTC
+Profile start="1970-01-01 00:00:42 UTC" description="GET /"
 #{spec_root}/files/hello.rb wall_time=0.0ms cpu_time=0.0ms
      0.0ms (    2) | print 'Hello '
 #{spec_root}/files/test.rb wall_time=113.7ms cpu_time=5.3ms
@@ -49,19 +50,19 @@ Profile start=1970-01-01 00:00:42 UTC
                    |   end
                    | end
 EOS
-      Pilfer::Logger.new(reporter).write(profile, start)
+      Pilfer::Logger.new(reporter).write(profile, start, description)
       output.should eq(expected)
     end
 
     it 'omits app root' do
       Pilfer::Logger.new(reporter, :app_root => spec_root).
-        write(profile, start)
+        write(profile, start, description)
       first_file.should eq('files/hello.rb')
     end
 
     it 'omits app root with trailing separator' do
       Pilfer::Logger.new(reporter, :app_root => spec_root + '/').
-        write(profile, start)
+        write(profile, start, description)
       first_file.should eq('files/hello.rb')
     end
 
@@ -72,17 +73,25 @@ EOS
 
       it 'omits the source of the nonexistent file' do
         expected = <<-EOS
-Profile start=1970-01-01 00:00:42 UTC
+Profile start="1970-01-01 00:00:42 UTC" description="GET /"
 (eval) wall_time=113.7ms cpu_time=5.3ms
 EOS
-        Pilfer::Logger.new(reporter).write(profile, start)
+        Pilfer::Logger.new(reporter).write(profile, start, description)
         output.should eq(expected)
       end
     end
 
     it 'appends to the log file' do
-      3.times { Pilfer::Logger.new(reporter).write(profile, start) }
+      3.times {
+        Pilfer::Logger.new(reporter).write(profile, start, description)
+      }
       output.scan('Profile start=').size.should eq(3)
     end
+
+    it 'ignores optional options' do
+      Pilfer::Logger.new(reporter, :app_root => spec_root).
+        write(profile, start, description, :async => false)
+      output.should_not be_nil
+    end
   end
 end

data/spec/pilfer/middleware_spec.rb

@@ -12,7 +12,8 @@ describe Pilfer::Middleware do
 
   it 'profiles and calls the downstream app' do
     app.should_receive(:call).with(env).once
-    profiler.should_receive(:profile).with(no_args).and_yield
+    profiler.should_receive(:profile).
+      with("GET /", :submit => :async).and_yield
     subject.call(env)
   end
 
@@ -33,8 +34,8 @@ describe Pilfer::Middleware do
 
     it 'passes file matcher to profiler and calls the downstream app' do
       app.should_receive(:call).with(env).once
-      profiler.should_receive(:profile_files_matching).with(file_matcher).
-        and_yield
+      profiler.should_receive(:profile_files_matching).
+        with(file_matcher, "GET /", :submit => :async).and_yield
       subject.call(env)
     end
   end

data/spec/pilfer/profiler_spec.rb

@@ -2,14 +2,17 @@ require 'helper'
 require 'pilfer/profiler'
 
 describe Pilfer::Profiler do
-  let(:reporter) { stub(:reporter, :write => nil) }
-  let(:start)    { stub(:start) }
+  let(:reporter)         { stub(:reporter, :write => nil) }
+  let(:reporter_options) { stub(:reporter_options) }
+  let(:description)      { stub(:description) }
+  let(:profiler)         { stub(:profiler, :call => :profiler_response) }
+  let(:start)            { stub(:start) }
 
   describe '#profile' do
     it 'profiles all files by default' do
-      profiler = stub(:profiler)
       profiler.should_receive(:call).with(/./)
-      Pilfer::Profiler.new(reporter).profile(profiler) { }
+      Pilfer::Profiler.new(reporter).
+        profile(description, reporter_options, profiler) { }
     end
 
     it 'returns value of app' do
@@ -18,17 +21,17 @@ describe Pilfer::Profiler do
         :profiler_response
       }
 
-      response = Pilfer::Profiler.new(reporter).profile(profiler) {
-        :app_response
-      }
+      response = Pilfer::Profiler.new(reporter).
+        profile(description, reporter_options, profiler) { :app_response }
 
       response.should eq(:app_response)
     end
 
     it 'writes profile to reporter' do
-      profiler = stub(:profiler, :call => :profiler_response)
-      reporter.should_receive(:write).with(:profiler_response, start)
-      Pilfer::Profiler.new(reporter).profile(profiler, start) { }
+      reporter.should_receive(:write).
+        with(:profiler_response, start, description, reporter_options)
+      Pilfer::Profiler.new(reporter).
+        profile(description, reporter_options, profiler, start) { }
     end
   end
 
@@ -36,17 +39,18 @@ describe Pilfer::Profiler do
     let(:matcher) { stub(:matcher) }
 
     it 'passes file matcher to profiler' do
-      profiler = stub(:profiler)
       profiler.should_receive(:call).with(matcher)
       Pilfer::Profiler.new(reporter).
-        profile_files_matching(matcher, profiler) { }
+        profile_files_matching(matcher, description, reporter_options,
+                               profiler) { }
     end
 
     it 'writes profile to reporter' do
-      profiler = stub(:profiler, :call => :profiler_response)
-      reporter.should_receive(:write).with(:profiler_response, start)
+      reporter.should_receive(:write).
+        with(:profiler_response, start, description, reporter_options)
       Pilfer::Profiler.new(reporter).
-        profile_files_matching(matcher, profiler, start) { }
+        profile_files_matching(matcher, description, reporter_options,
+                               profiler, start) { }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pilfer
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre4
+  version: 1.0.0
 platform: ruby
 authors:
 - Eric Lindvall
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-22 00:00:00.000000000 Z
+date: 2013-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rblineprof
@@ -39,7 +39,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-description: 
+description: pilfer uses rblineprof to measure how long each line of code takes to
+  execute and the number of times it was called.
 email:
 - eric@sevenscale.com
 - larry@marburger.cc
@@ -55,10 +56,13 @@ files:
 - lib/pilfer/middleware.rb
 - lib/pilfer/profile.rb
 - lib/pilfer/profiler.rb
+- lib/pilfer/server.rb
 - lib/pilfer/version.rb
+- lib/pilfer.rb
 - spec/files/hello.rb
 - spec/files/test.rb
 - spec/helper.rb
+- spec/integration_spec.rb
 - spec/pilfer/logger_spec.rb
 - spec/pilfer/middleware_spec.rb
 - spec/pilfer/profile_spec.rb
@@ -88,11 +92,12 @@ rubyforge_project:
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: Look into your ruby with rblineprof
+summary: line-profiler for ruby and rack
 test_files:
 - spec/files/hello.rb
 - spec/files/test.rb
 - spec/helper.rb
+- spec/integration_spec.rb
 - spec/pilfer/logger_spec.rb
 - spec/pilfer/middleware_spec.rb
 - spec/pilfer/profile_spec.rb