rspec-benchmark 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7284782b6fbaacc643bbe29f58c30aa05985b9c7
+  data.tar.gz: 8e5fd4afde4a6cba55e537d8399652a286675021
+SHA512:
+  metadata.gz: 72f9771b9edea737412eb8e241d70f4dd56866632c267ce72b71719567cd0b19d7769b4425067050d90ae84bd049a0cc6f75e17f2da97f1fdcc92747b2bea06f
+  data.tar.gz: 951f9b31da5bea5c0df8db36fc2a2a2befeef46d92e061f5dcc8e08f6c08489f36035f40e3321199439f961ec27eeb5f28fbe48daed4da87bf612c5e85f63023

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,28 @@
+---
+language: ruby
+sudo: false
+cache: bundler
+bundler_args: --without yard benchmarks
+script: "bundle exec rake ci"
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - jruby-19mode
+  - jruby
+  - jruby-head
+  - rbx-2
+env:
+  global:
+    - JRUBY_OPTS="-Xcli.debug=true --debug"
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+  fast_finish: true
+branches:
+  only: master
+notifications:
+  email: false

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## [v0.1.0] - 2016-01-25
+
+Initial release
+
+[v0.1.0]: https://github.com/peter-murach/rspec-benchmark/compare/v0.1.0

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :metrics do
+  gem 'coveralls', '~> 0.8.9'
+  gem 'simplecov', '~> 0.10.0'
+  gem 'yardstick', '~> 0.9.9'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Piotr Murach
+
+MIT License
+
+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.md

@@ -0,0 +1,137 @@
+# RSpec::Benchmark
+[![Gem Version](https://badge.fury.io/rb/rspec-benchmark.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/peter-murach/rspec-benchmark.svg?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/peter-murach/rspec-benchmark/badges/gpa.svg)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/peter-murach/rspec-benchmark/badge.svg?branch=master)][coverage]
+[![Inline docs](http://inch-ci.org/github/peter-murach/rspec-benchmark.svg?branch=master)][inchpages]
+
+[gem]: http://badge.fury.io/rb/rspec-benchmark
+[travis]: http://travis-ci.org/peter-murach/rspec-benchmark
+[codeclimate]: https://codeclimate.com/github/peter-murach/rspec-benchmark
+[coverage]: https://coveralls.io/github/peter-murach/rspec-benchmark?branch=master
+[inchpages]: http://inch-ci.org/github/peter-murach/rspec-benchmark
+
+> Performance testing matchers for RSpec
+
+**RSpec::Benchmark** uses [benchmark-perf](https://github.com/peter-murach/benchmark-perf) for measurements.
+
+## Why?
+
+Integration and unit tests ensure that changing code maintains expected functionality. What is not guaranteed is the code changes impact on library performance. It is easy to refactor your way out of fast to slow code.
+
+If you are new to performance testing you may find [Caveats](#3-caveats) section helpful.
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. Filtering](#2-filtering)
+* [3. Caveats](#3-caveats)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rspec-benchmark'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rspec-benchmark
+
+## 1. Usage
+
+For matchers to be available globally, in `spec_helper.rb` do:
+
+```ruby
+require 'rspec-benchmark'
+
+RSpec.configure do |config|
+  config.include RSpec::Benchmark::Matchers
+end
+```
+
+This will add the `perform_under` and `perform_at_least` matchers to express expected performance benchmark from code executed inside the expectation.
+
+Alternatively, you can add matchers for particular example:
+
+```ruby
+RSpec.describe "Performance testing" do
+  include RSpec::Benchmark::Matchers
+end
+```
+
+### 1.1 Execution time
+
+The `perform_under` matcher answers the question of how long does it take to perform a given block of code on average. The measurements are taken executing the block of code in a child process for accurent cpu times.
+
+```ruby
+expect { ... }.to perform_under(0.01).sec
+```
+
+All measurements are assumed to be expressed as seconds. However, you can also provide time in `ms`, `us` and `ns`. The equivalent example in `ms` would be:
+
+```ruby
+expect { ... }.to perform_under(10).ms
+```
+
+by default the above code will be sampled `30` times but you can change this by using `and_sample` like so:
+
+```ruby
+expect { ... }.to perform_under(0.01).and_sample(10)
+```
+
+### 1.2 Iterations
+
+The `perform_at_least` matcher allows you to establish performance benchmark of how many iterations per second a given block of code should perform. For example, to expect a given code to perform at least 10K iterations per second do:
+
+```ruby
+expect { ... }.to perform_at_least(10000).ips
+```
+
+The `ips` part is optional but its usage clarifies the intent.
+
+## 2 Filtering
+
+Usually performance tests are best left for CI or occasional runs that do not affect TDD/BDD cycle. To achieve isolation you can use RSpec filters. For instance, in `spec_helper`:
+
+```
+config.filter_run_excluding performance: true
+```
+
+and then in your example group do:
+
+```ruby
+RSpec.describe ..., performance: true do
+  ...
+end
+```
+
+Another option is to simply isolate the performance specs in separate directory suc as `spec/performance/...` and add custom rake task.
+
+## 3 Caveats
+
+When writing performance tests things to be mindful are:
+
++ The tests may **potentially be flaky** thus its best to use sensible boundaries:
+  - **too strict** boundaries may cause false positives, making tests fail
+  - **too relaxed** boundaries may also lead to false positives missing actual performance regressions
++ Generally performance tests will be **slow**, but you may try to avoid _unnecessarily_ slow tests by choosing smaller maximum value for sampling
+
+If you have any other observations please share them!
+
+## Contributing
+
+1. Fork it ( https://github.com/peter-murach/rspec-benchmark/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Copyright
+
+Copyright (c) 2016 Piotr Murach. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each(&method(:import))
+
+desc 'Run all specs'
+task ci: %w[ spec ]
+
+task default: :spec

data/lib/rspec-benchmark.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'rspec/benchmark'

data/lib/rspec/benchmark.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'benchmark-perf'
+
+require 'rspec/benchmark/format_time'
+require 'rspec/benchmark/matchers'
+require 'rspec/benchmark/version'

data/lib/rspec/benchmark/format_time.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module RSpec
+  module Benchmark
+    # Format time for easy matcher reporting
+    #
+    # @param [Float] time
+    #   the time to format
+    #
+    # @return [String]
+    #   the human readable time value
+    #
+    # @api public
+    def format_time(time)
+      if time >= 100.0
+        "%.0f sec" % [time]
+      elsif time >= 1.0
+        "%.3g sec" % [time]
+      elsif time >= 1e-3
+        "%.3g ms" % [time * 1e3]
+      elsif time >= 1e-6
+        "%.3g μs" % [time * 1e6]
+      else
+        "%.0f ns" % [time * 1e9]
+      end
+    end
+    module_function :format_time
+  end # Benchmark
+end # RSpec

data/lib/rspec/benchmark/iteration_matcher.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module RSpec
+  module Benchmark
+    module IterationMatcher
+      # Implements the `perform_at_least` matcher
+      #
+      # @api private
+      class Matcher
+        def initialize(iterations, options = {})
+          @iterations = iterations
+        end
+
+        # Indicates this matcher matches against a block
+        #
+        # @return [True]
+        #
+        # @api private
+        def supports_block_expectations?
+          true
+        end
+
+        # @return [Boolean]
+        #
+        # @api private
+        def matches?(block)
+          @bench = ::Benchmark::Perf::Iteration.new
+          @average, @stddev, _ = @bench.run(&block)
+          @iterations <= (@average + 3 * @stddev)
+        end
+
+        def ips
+          self
+        end
+
+        def failure_message
+          "expected block to #{description}, but #{positive_failure_reason}"
+        end
+
+        def failure_message_when_negated
+          "expected block not to #{description}, but #{negative_failure_reason}"
+        end
+
+        def description
+          "perform at least #{@iterations} i/s"
+        end
+
+        def actual
+          "%d (± %d%%) i/s" % [@average, (@stddev / @average.to_f) * 100]
+        end
+
+        def positive_failure_reason
+          "performed only #{actual}"
+        end
+
+        def negative_failure_reason
+          "performed #{actual}"
+        end
+      end
+    end # IterationMatcher
+  end # Benchmark
+end # RSpec

data/lib/rspec/benchmark/matchers.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rspec/benchmark/timing_matcher'
+require 'rspec/benchmark/iteration_matcher'
+
+module RSpec
+  module Benchmark
+    # Provides a number of useful performance testing expectations
+    #
+    # These matchers can be exposed by including the this module in
+    # a spec:
+    #
+    #   RSpec.describe "Performance testing" do
+    #     include RSpec::Benchmark::Matchers
+    #   end
+    #
+    # or you can include in globablly in a spec_helper.rb file:
+    #
+    #   RSpec.configure do |config|
+    #     config.inlucde(RSpec::Benchmark::Matchers)
+    #   end
+    #
+    # @api public
+    module Matchers
+      # Passes if code block performs at least iterations
+      #
+      # @param [Integer] iterations
+      #
+      # @example
+      #   expect { ... }.to perform_at_least(10000)
+      #   expect { ... }.to perform_at_least(10000).ips
+      #
+      # @api public
+      def perform_at_least(iterations, options = {})
+        IterationMatcher::Matcher.new(iterations, options)
+      end
+
+      # Passes if code block performs under threshold
+      #
+      # @param [Float] threshold
+      #
+      # @example
+      #   expect { ... }.to peform_under(0.001)
+      #   expect { ... }.to peform_under(0.001).sec
+      #   expect { ... }.to peform_under(10).ms
+      #
+      # @api public
+      def perform_under(threshold, options = {})
+        TimingMatcher::Matcher.new(threshold, options)
+      end
+    end # Matchers
+  end # Benchmark
+end # RSpec

data/lib/rspec/benchmark/timing_matcher.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+module RSpec
+  module Benchmark
+    module TimingMatcher
+      # Implements the `perform_under` matcher
+      #
+      # @api private
+      class Matcher
+        include RSpec::Benchmark
+
+        attr_reader :threshold
+
+        def initialize(threshold, options = {})
+          @threshold = threshold
+          @samples = options.fetch(:samples) { 30 }
+          @scale = threshold.to_s.split(/\./).last.size
+          @block = nil
+          @confidence_interval = nil
+        end
+
+        # Indicates this matcher matches against a block
+        #
+        # @return [True]
+        #
+        # @api private
+        def supports_block_expectations?
+          true
+        end
+
+        # @return [Boolean]
+        #
+        # @api private
+        def matches?(block)
+          @block = block
+          return false unless block.is_a?(Proc)
+          @bench = ::Benchmark::Perf::ExecutionTime.new
+          @average, @stddev = @bench.run(@samples, &block)
+          @average <= @threshold
+        end
+
+        def does_not_match?(block)
+          !matches?(block) && block.is_a?(Proc)
+        end
+
+        def and_sample(samples)
+          @samples = samples
+          self
+        end
+
+        def secs
+          self
+        end
+        alias_method :sec, :secs
+
+        # Tell this matcher to convert threshold to ms
+        # @api public
+        def ms
+          @threshold /= 1e3
+          self
+        end
+
+        # Tell this matcher to convert threshold to us
+        # @api public
+        def us
+          @threshold /= 1e6
+          self
+        end
+
+        # Tell this matcher to convert threshold to ns
+        # @api public
+        def ns
+          @threshold /= 1e9
+          self
+        end
+
+        def failure_message
+          "expected block to #{description}, but #{positive_failure_reason}"
+        end
+
+        def failure_message_when_negated
+          "expected block to not #{description}, but #{negative_failure_reason}"
+        end
+
+        def description
+          "perform under #{format_time(@threshold)}"
+        end
+
+        def actual
+          "#{format_time(@average)} (± #{format_time(@stddev)})"
+        end
+
+        def positive_failure_reason
+          return 'was not a block' unless @block.is_a?(Proc)
+          "performed above #{actual} "
+        end
+
+        def negative_failure_reason
+          return 'was not a block' unless @block.is_a?(Proc)
+          "performed #{actual} under"
+        end
+      end # Matcher
+    end # TiminingMatcher
+  end # Benchmark
+end # RSpec

data/lib/rspec/benchmark/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module RSpec
+  module Benchmark
+    VERSION = "0.1.0"
+  end # Benchmark
+end # RSpec

data/rspec-benchmark.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rspec/benchmark/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rspec-benchmark"
+  spec.version       = RSpec::Benchmark::VERSION
+  spec.authors       = ["Piotr Murach"]
+  spec.email         = [""]
+  spec.summary       = %q{Performance testing matchers for RSpec}
+  spec.description   = %q{Performance testing matchers for RSpec that provide simple way to specify speed benchmark expectations}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'benchmark-perf', '~> 0.1.0'
+  spec.add_dependency 'rspec', '>= 3.0.0', '< 4.0.0'
+
+  spec.add_development_dependency 'bundler', '>= 1.5.0', '< 2.0'
+  spec.add_development_dependency 'rake'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
+require 'rspec-benchmark'
+
+RSpec.configure do |config|
+  config.include(RSpec::Benchmark::Matchers)
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 2
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/unit/format_time_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+RSpec.describe RSpec::Benchmark, '#format_time' do
+  {
+    1e-10   => "0 ns",
+    0.42e-6 => "420 ns",
+    3.4e-6  => "3.4 μs",
+    34e-6   => "34 μs",
+    340e-6  => "340 μs",
+    1e-3    => "1 ms",
+    12e-3   => "12 ms",
+    1.0     => "1 sec",
+    1.2345  => "1.23 sec",
+    123.45  => "123 sec",
+    1234    => "1234 sec"
+  }.each do |input, expected|
+    it "#{input} -> #{expected}" do
+      expect(described_class.format_time(input)).to eq(expected)
+    end
+  end
+end

data/spec/unit/perform_at_least_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+RSpec.describe '#perform_at_least' do
+
+  context "expect { ... }.to perform_at_least(...).ips" do
+    it "passes if the block perfoms more than 10K ips" do
+      expect {
+        'x' * 1024 * 10
+      }.to perform_at_least(10_000).ips
+    end
+
+    it "fails if the block performs less than 10K ips" do
+      expect {
+        expect {
+          'x' * 1024 * 1024
+        }.to perform_at_least(10_000).ips
+      }.to raise_error(/expected block to perform at least 10000 i\/s, but performed only \d+ \(± \d+%\) i\/s/)
+    end
+  end
+
+  context "expect { ... }.not_to perform_at_least(...).ips" do
+    it "passes if the block does not perform more than 10K ips" do
+      expect {
+        'x' * 1024 * 1024 * 10
+      }.not_to perform_at_least(10_000).ips
+    end
+
+    it "fails if the block performs more than 10K ips" do
+      expect {
+        expect { 'x' * 1024 }.not_to perform_at_least(10_000).ips
+      }.to raise_error(/expected block not to perform at least 10000 i\/s, but performed \d+ \(± \d+%\) i\/s/)
+    end
+  end
+end

data/spec/unit/perform_under_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+RSpec.describe 'RSpec::Benchmark::TimingMatcher', '#perform_under' do
+
+  context "expect { ... }.to perfom_under(...).and_sample" do
+    it "passes if the block performs under threshold" do
+      expect {
+        'x' * 1024 * 10
+      }.to perform_under(0.006).sec.and_sample(10)
+    end
+
+    it "fails if the block performs above threshold" do
+      expect {
+        expect {
+          'x' * 1024 * 1024 * 100
+        }.to perform_under(0.0001).and_sample(5)
+      }.to raise_error(/expected block to perform under 100 μs, but performed above \d+(\.\d+)? ([μmn]s|sec) \(± \d+(\.\d+)? ([μmn]s|sec)\)/)
+    end
+  end
+
+  context "expect { ... }.not_to perform_under(...).and_sample" do
+    it "passes if the block does not perform under threshold" do
+      expect {
+        'x' * 1024 * 1024 * 10
+      }.to_not perform_under(0.001).and_sample(2)
+    end
+
+    it "fails if the block perfoms under threshold" do
+      expect {
+        expect {
+          'x' * 1024 * 1024 * 10
+        }.to_not perform_under(1).and_sample(2)
+      }.to raise_error(/expected block to not perform under 1 sec, but performed \d+(\.\d+)? ([μmn]s|sec) \(± \d+(\.\d+)? ([μmn]s|sec)\) under/)
+    end
+  end
+
+  context 'threshold conversions' do
+    it "converts 1ms to sec" do
+      matcher = perform_under(1).ms
+      expect(matcher.threshold).to eq(0.001)
+    end
+
+    it "converts 1000us to sec" do
+      matcher = perform_under(1000).us
+      expect(matcher.threshold).to eq(0.001)
+    end
+
+    it "converts ns to sec" do
+      matcher = perform_under(100_000).ns
+      expect(matcher.threshold).to eq(0.0001)
+    end
+  end
+end

data/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+desc 'Measure code coverage'
+task :coverage do
+  begin
+    original, ENV['COVERAGE'] = ENV['COVERAGE'], 'true'
+    Rake::Task['spec'].invoke
+  ensure
+    ENV['COVERAGE'] = original
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc 'Run all specs'
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.pattern = 'spec/{unit,integration}{,/*/**}/*_spec.rb'
+  end
+
+  namespace :spec do
+    desc 'Run unit specs'
+    RSpec::Core::RakeTask.new(:unit) do |task|
+      task.pattern = 'spec/unit{,/*/**}/*_spec.rb'
+    end
+
+    desc 'Run integration specs'
+    RSpec::Core::RakeTask.new(:integration) do |task|
+      task.pattern = 'spec/integration{,/*/**}/*_spec.rb'
+    end
+
+    desc 'Run performance specs'
+    RSpec::Core::RakeTask.new(:perf) do |task|
+      task.pattern = 'spec/performance{,/*/**}/*_spec.rb'
+    end
+  end
+
+rescue LoadError
+  %w[spec spec:unit spec:integration spec:perf].each do |name|
+    task name do
+      $stderr.puts "In order to run #{name}, do `gem install rspec`"
+    end
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: rspec-benchmark
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Murach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark-perf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Performance testing matchers for RSpec that provide simple way to specify
+  speed benchmark expectations
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rspec-benchmark.rb
+- lib/rspec/benchmark.rb
+- lib/rspec/benchmark/format_time.rb
+- lib/rspec/benchmark/iteration_matcher.rb
+- lib/rspec/benchmark/matchers.rb
+- lib/rspec/benchmark/timing_matcher.rb
+- lib/rspec/benchmark/version.rb
+- rspec-benchmark.gemspec
+- spec/spec_helper.rb
+- spec/unit/format_time_spec.rb
+- spec/unit/perform_at_least_spec.rb
+- spec/unit/perform_under_spec.rb
+- tasks/coverage.rake
+- tasks/spec.rake
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Performance testing matchers for RSpec
+test_files:
+- spec/spec_helper.rb
+- spec/unit/format_time_spec.rb
+- spec/unit/perform_at_least_spec.rb
+- spec/unit/perform_under_spec.rb
+has_rdoc: