big-o 0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+.yardoc

data/.rspec

@@ -0,0 +1,3 @@
+--format d
+--require spec_helper
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem 'yard', '~>0.8.2', :groups => [:development, :test]
+
+group :test do
+  gem "rspec", '~>2.10.0'
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Vincent Bonmalais
+
+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,88 @@
+# Big-O
+
+Big-O is a gem which analyse an anonymous function and verify that it follow a specific pattern
+in its memory usage or its execution time.
+
+## Requirements
+
+Calculation of memory space is done via `ps`, and therefore, doesn't work on Windows.
+
+This gem has been tested on Mac OS X, using Ruby 1.9.3.
+
+## Install
+
+Installation is made through RubyGem:
+
+```
+gem install big-o
+```
+
+## Usage
+
+### Directly in your code
+
+Checking if a function has a complexity of O(n) is as simple as this:
+
+```ruby
+require 'big-o'
+
+time_complexity = BigO::TimeComplexity({
+  :fn    => lambda { |n| do_something_time_consuming(n) },
+  :level => lambda { |n| n }
+})
+time_complexity.process # => true if it is growing in time constantly.
+```
+
+It is also possible to define multiple configuration parameters:
+
+```ruby
+require 'big-o'
+
+space_complexity = BigO::SpaceComplexity({
+  :fn => lambda { |n| do_something_space_consuming(n) }
+  :level => lambda { |n| n },
+  :range => 1..20,                # value of n
+  :timeout => 10,                 # time in seconds
+  :approximation => 0.05,         # percentage
+  :error_pct => 0.05,             # percentage
+  :minimum_result_set_size => 3   # minimum results
+})
+```
+
+### RSpec Matchers
+
+If you are using RSpec, there is a matcher already defined for matching a complexity level:
+
+```ruby
+require 'big-o'
+require 'big-o-matchers'
+
+describe 'do_something_time_consuming' do
+  before :each do
+    @time_complexity = BigO::TimeComplexity({
+      :fn    => lambda { |n| do_something_time_consuming(n) }
+    })
+  end
+
+  it 'should have a complexity of O(n)' do
+    @time_complexity.should match_complexity_level 'O(n)', lambda { |n| n }
+  end
+
+  it 'should not have a complexity of O(1)' do
+    @time_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+  end
+end
+```
+
+The string used as the first parameter (e.g. `'O(n)'`) is used to describe the lambda given as the
+second parameter.
+
+## Reference
+
+You may want to read more on the subject by reading:
+* http://en.wikipedia.org/wiki/Analysis_of_algorithms
+* http://en.wikipedia.org/wiki/Big_O_notation
+
+## License
+
+Complexity is licensed under the MIT License - see the LICENSE file for details

data/big-o.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name        = 'big-o'
+  s.version     = '0.1'
+  s.date        = '2012-07-25'
+  s.summary     = "Calculate function complexity (using Big O notation)"
+  s.description = "Big-O is a gem which analyse an anonymous function and verify that it " +
+      "follow a specific pattern in its memory usage or its execution time."
+  s.authors     = ["Vincent Bonmalais"]
+  s.email       = 'vbonmalais@gmail.com'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- spec`.split("\n")
+  s.homepage    = 'https://github.com/kouno/big-o'
+
+  s.add_development_dependency('rspec', '~>2.10.0')
+end

data/lib/big-o-matchers.rb

@@ -0,0 +1 @@
+require 'big-o/matchers/match_complexity_level'

data/lib/big-o.rb

@@ -0,0 +1,7 @@
+require 'timeout'
+require 'benchmark'
+
+require 'big-o/complexity_base'
+require 'big-o/time_complexity'
+require 'big-o/space_complexity'
+require 'big-o/exceptions'

data/lib/big-o/complexity_base.rb

@@ -0,0 +1,128 @@
+module BigO
+  # ComplexityBase regroup every process common to the benchmarking of a function.
+  module ComplexityBase
+
+    # @return [Boolean] Result from measurement
+    attr_accessor :result
+
+    # @return [Hash] Contains the whole benchmark
+    attr_accessor :result_set
+
+    # @return [Float] Element on which the whole benchmark is based (for <code>n = 1</code>)
+    attr_accessor :scale
+
+    # @return [Hash] Contains the different configurable options
+    attr_accessor :options
+
+    # Configures default values.
+    #
+    # @param [Hash] options the options necessary to benchmark the given lambda. Any of these options
+    #               can be defined just before running a simulation using <code>options</code>.
+    #
+    #     {
+    #        :fn => lambda { |n| do_something(n) }  # function which will be measured [required]
+    #        :level => lambda { |n| n }             # complexity of the function [required]
+    #        :range => 1..20,                       # values of `n` for which it will run the function
+    #        :timeout => 10,                        # time (in seconds) after which the simulation will stop running
+    #        :approximation => 0.05,                # percentage by which we approximate our expected results
+    #        :error_pct => 0.05,                    # percentage of times where we allow errors due to concurrent processing
+    #        :minimum_result_set_size => 3          # minimum number of results we need to have consistent data
+    #      }
+    # @return [void]
+    def initialize(options = {})
+      @options = { :range => 1..20,
+                   :timeout => 10,
+                   :approximation => 0.05,
+                   :error_pct => 0.05,
+                   :minimum_result_set_size => 3 }
+
+      @options.merge!(options)
+    end
+
+    # Benchmarks the given function (<code>@fn</code>) and tells if it follows the given pattern
+    # (<code>@options[:level]</code>).
+    #
+    # @return [Boolean]
+    def process
+      @scale ||= get_scale
+      examine_result_set(*run_simulation)
+    end
+
+    # Runs simulation.
+    #
+    # A simulation can fail to execute every element in <code>range</code> because it exceeded the timeout limit. If no result
+    # was returned in the `timeout` time frame, this method will generate an exception.
+    #
+    # @return [Array] contains an array (first element) of values which are the measurement of the function
+    #                 and another array (second element) of values which are the expected values for the first one.
+    # @raise [Timeout::Error]
+    def run_simulation
+      real_complexity     = {}
+      expected_complexity = {}
+
+      begin
+        Timeout::timeout(@options[:timeout]) do
+          @options[:range].each do |n|
+            next if (indicator = measure(n, &@options[:fn])) == 0
+            real_complexity[n]     = indicator
+            expected_complexity[n] = @options[:level].call(n)
+          end
+        end
+      rescue Timeout::Error => e
+        if real_complexity.empty? || expected_complexity.empty?
+          raise e
+        end
+      end
+
+      @result_set = real_complexity
+      [real_complexity, expected_complexity]
+    end
+
+    # Parses data from <code>#run_simulation</code>.
+    #
+    # <code>examine_result_set</code> will return true only if these conditions are met:
+    # - expected complexity is never exceeded. Some inconsistencies may however be allowed
+    #   (see <code>@options[:error_pct]</code>).
+    # - there is a minimum of X results in real_complexity, where X is <code>@options[:minimum_result_set_size]</code>.
+    #   if this condition is not met, an exception will be thrown.
+    #
+    # @param [Array] real_complexity
+    # @param [Array] expected_complexity
+    # @return [Boolean]
+    # @raise [SmallResultSetError]
+    def examine_result_set(real_complexity, expected_complexity)
+      if real_complexity.size <= @options[:minimum_result_set_size]
+        raise SmallResultSetError.new(@options[:minimum_result_set_size])
+      end
+
+      allowed_inconsistencies = (expected_complexity.size * @options[:error_pct]).floor
+      expected_complexity.each do |n, level|
+        next if n == 1
+        estimated_complexity  = @scale * level
+        estimated_complexity += estimated_complexity * @options[:approximation]
+        if estimated_complexity <= real_complexity[n]
+          if allowed_inconsistencies > 0
+            allowed_inconsistencies -= 1
+            next
+          end
+          @result = false
+          break
+        end
+      end
+
+      @result = true if @result.nil?
+      @result
+    end
+
+    # Finds what is the first measure of our function.
+    #
+    # @return [Float]
+    def get_scale
+      runs = []
+      10.times do
+        runs << measure(1, &@options[:fn])
+      end
+      runs.inject(:+) / 10
+    end
+  end
+end

data/lib/big-o/exceptions.rb

@@ -0,0 +1,21 @@
+module BigO
+  # The function could not be run more than X times (where X is a configurable value).
+  #
+  # This exception happens if the function is too slow to run, or if the timeout is too short.
+  class SmallResultSetError < StandardError
+    # @param [Integer] resultset_size number of values the result set contains.
+    def initialize(resultset_size)
+      super "Less than #{resultset_size} values could be retrieved." +
+          " Try using longer timeout or a different range. (function complexity may be too high)"
+    end
+  end
+
+  # The function runs too fast and can't be quantified by our measurement tool.
+  #
+  # To fix this error, it is possible to augment the number of times the function should run.
+  class InstantaneousExecutionError < StandardError
+    def initialize
+      super "Function execution time can't be quantified. (execution speed close to instantaneous)"
+    end
+  end
+end

data/lib/big-o/matchers/match_complexity_level.rb

@@ -0,0 +1,32 @@
+RSpec::Matchers.define :match_complexity_level do |o_notation, complexity_level|
+  match do |complexity|
+    complexity.options[:level] = complexity_level
+    complexity.process
+  end
+
+  failure_message_for_should do |complexity|
+    # since we are playing around with floating values,
+    # sorting the result_set helps minimising issues with addition of floats
+    result_set = complexity.result_set.sort
+    total = result_set.inject(0) { |sum, r| sum + r[1] }.to_f
+    "expected a complexity level of #{o_notation}, " +
+        "got scale: #{complexity.scale} min: #{result_set[0][1]} " +
+        "max: #{result_set[-1][1]} " +
+        "avg: #{total / result_set.size} " +
+        "total values: #{result_set.size} on #{complexity.options[:range]}"
+  end
+
+  failure_message_for_should_not do |complexity|
+    result_set = complexity.result_set.sort
+    total = result_set.inject(0) { |sum, r| sum + r[1] }.to_f
+    "expected a complexity level over #{o_notation}, " +
+        "got scale: #{complexity.scale} min: #{result_set[0][1]} " +
+        "max: #{result_set[-1][1]} " +
+        "avg: #{total / result_set.size} " +
+        "total values: #{result_set.size} on #{complexity.options[:range]}"
+  end
+
+  description do
+    "should match complexity level #{o_notation}"
+  end
+end

data/lib/big-o/space_complexity.rb

@@ -0,0 +1,38 @@
+module BigO
+  # Measure space complexity.
+  class SpaceComplexity
+    include ComplexityBase
+
+    # Measures the memory space that <code>fn</code> is using.
+    #
+    # @param [Array] args arguments which the given block should take
+    # @yield function which should be measured (fn)
+    # @return [Float] measurement
+    def measure(*args, &b)
+      memory_measures = []
+      GC.disable
+
+      pid = Process.fork do
+        memory_measures << `ps -o rss= -p #{Process.pid}`.to_i
+        b.call(*args)
+        memory_measures << `ps -o rss= -p #{Process.pid}`.to_i
+        exit
+      end
+
+      while (memory_indicator = `ps -o rss= -p #{pid}`.to_i)
+        break if memory_indicator == 0
+        memory_measures << memory_indicator
+      end
+
+      Process.wait
+
+      GC.enable
+
+      if memory_measures.size > 2
+        memory_measures.max - memory_measures.min
+      else
+        0
+      end
+    end
+  end
+end

data/lib/big-o/time_complexity.rb

@@ -0,0 +1,32 @@
+module BigO
+  # Measure time complexity.
+  class TimeComplexity
+    include ComplexityBase
+
+    # Raises the error percentage due to possible concurrency issue on the system (which in
+    # certain cases may cause some measures to be far longer than others).
+    def initialize(options = {})
+      options = { :error_pct => 0.1 }.merge(options)
+      super(options)
+    end
+
+    # Checks if the function can be measured and throw an error if it could not.
+    def process
+      @scale ||= get_scale
+      raise InstantaneousExecutionError.new unless @scale > 0
+      super
+    end
+
+    # Measures the execution time that <code>fn</code> is using.
+    #
+    # @param [Array] args arguments which the given block should take
+    # @yield function which should be measured (fn)
+    # @return [Float] measurement
+    def measure(*args, &b)
+      t0 = Process.times
+      b.call(*args)
+      t1 = Process.times
+      t1.utime - t0.utime
+    end
+  end
+end

data/spec/big-o/complexity_base_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+include BigO
+
+describe ComplexityBase do
+  before :all do
+    class FunctionComplexity
+      include ComplexityBase
+
+      def measure
+        1
+      end
+    end
+  end
+
+  context 'with default values' do
+    before :each do
+      @fn_complexity = FunctionComplexity.new
+    end
+
+    it 'should have a timeout of 10 seconds' do
+      @fn_complexity.options[:timeout].should == 10
+    end
+
+    it 'should have no result defined' do
+      @fn_complexity.result.should be_nil
+    end
+
+    it 'should have an approximation of 5%' do
+      @fn_complexity.options[:approximation].should == 0.05
+    end
+
+    it 'should refuse to process less than 4 values when processing a function' do
+      real_complexity     = {}
+      expected_complexity = {}
+      3.times do |i|
+        real_complexity[i]     = i
+        expected_complexity[i] = i
+      end
+
+      @fn_complexity.scale = 1
+      lambda {
+        @fn_complexity.examine_result_set(real_complexity, expected_complexity)
+      }.should raise_error(SmallResultSetError)
+    end
+  end
+
+  context 'with overwritten values' do
+    before :each do
+      @fn_complexity = FunctionComplexity.new({ :timeout => 1,
+                                                :approximation => 0.1 })
+    end
+
+    it 'should have the configured values' do
+      @fn_complexity.options[:timeout].should == 1
+      @fn_complexity.options[:approximation].should == 0.1
+    end
+  end
+end

data/spec/big-o/space_complexity_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+include BigO
+
+describe SpaceComplexity do
+  before :each do
+    @space_complexity = SpaceComplexity.new
+  end
+
+  it 'should raise an exception if timeout is reached and no result was found' do
+    @space_complexity.options[:timeout] = 0.001
+    @space_complexity.options[:fn]      = lambda { |_| simulate_memory_space(1) }
+    lambda { @space_complexity.process }.should raise_error(Timeout::Error)
+  end
+
+  describe '#process on complexity O(1)' do
+    before :each do
+      @space_complexity.options[:fn] = lambda { |_| simulate_memory_space(1024) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @space_complexity.options[:approximation] = 0.2
+      @space_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+  end
+
+  describe '#process on complexity O(n)' do
+    before :each do
+      @space_complexity.options[:fn] = lambda { |n| simulate_memory_space(1024 * n) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @space_complexity.should match_complexity_level 'O(n)', lambda { |n| n }
+    end
+
+    it 'should return false if the complexity does not match (too low)' do
+      @space_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+
+  end
+
+  describe '#process on complexity O(n**2)' do
+    before :each do
+      @space_complexity.options[:fn] = lambda { |n| simulate_memory_space(1024 * n**2) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @space_complexity.should match_complexity_level 'O(n^2)', lambda { |n| n**2 }
+    end
+
+    it 'should return false if the complexity does not match (too low)' do
+      @space_complexity.should_not match_complexity_level 'O(n)', lambda { |n| n }
+
+      @space_complexity.options[:approximation] = 0.2
+      @space_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+  end
+end

data/spec/big-o/time_complexity_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+include BigO
+
+describe TimeComplexity do
+  before :each do
+    @time_complexity = TimeComplexity.new
+  end
+
+  it 'should raise an exception if timeout is reached and no result was found' do
+    @time_complexity.options[:timeout] = 0.001
+    @time_complexity.options[:fn]      = proc { simulate_utime_processing(1) }
+    lambda { @time_complexity.process }.should raise_error(Timeout::Error)
+  end
+
+  describe '#process on complexity O(1)' do
+    before :each do
+      @time_complexity.options[:fn] = lambda { |_| simulate_utime_processing(0.5) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @time_complexity.options[:approximation] = 0.2
+      @time_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+  end
+
+  describe '#process on complexity O(n)' do
+    before :each do
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(0.5 * n) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @time_complexity.should match_complexity_level 'O(n)', lambda { |n| n }
+    end
+  end
+
+  describe '#process on complexity O(n**2)' do
+    before :each do
+      @time_complexity.options[:minimum_result_set_size] = 0
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(0.5 * (n**2)) }
+    end
+
+    it 'should run the function and produce a report when time threshold is hit' do
+      @time_complexity.should match_complexity_level 'O(n^2)', lambda { |n| n**2 }
+    end
+
+    it 'should return false if the complexity does not match (too low)' do
+      @time_complexity.options[:approximation] = 0.2
+      @time_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+  end
+
+  describe 'very small execution time functions (0.1 second and below)' do
+    it 'should still be valid in case of O(n**2)' do
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(0.01 * n**2) }
+      @time_complexity.should     match_complexity_level 'O(n**2)',     lambda { |n| n**2 }
+      @time_complexity.should_not match_complexity_level 'O(n log(n))', lambda { |n| n * Math::log(n) }
+      @time_complexity.should_not match_complexity_level 'O(1)',        lambda { |_| 1 }
+    end
+
+    it 'should still be valid in case of O(n)' do
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(0.01 * n) }
+      @time_complexity.should     match_complexity_level 'O(n)', lambda { |n| n }
+      @time_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
+    end
+
+    it 'should throw an error if execution time is not measurable for n = 1 (execution time close to ~0.001 second)' do
+      @time_complexity.options[:fn] = lambda { |n| 0.001 * n**2 }
+      lambda { @time_complexity.process }.should raise_error(InstantaneousExecutionError)
+    end
+  end
+end

data/spec/helpers/simulation.rb

@@ -0,0 +1,18 @@
+module BigO
+  module Helpers
+    ONE_KILO_OCTET = 'a' * 1024
+
+    def simulate_utime_processing(seconds)
+      t0 = Process.times
+      begin
+        t1 = Process.times
+      end while (t1.utime - t0.utime) < seconds
+    end
+
+    def simulate_memory_space(ko)
+      space = ONE_KILO_OCTET * ko
+      sleep(0.01)
+      space
+    end
+  end
+end

data/spec/matchers/match_complexity_level_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+include BigO
+
+describe 'match_complexity_level matcher' do
+  before :each do
+    @test_complexity = SpaceComplexity.new({ :fn => lambda { |n| simulate_memory_space(1024 * n) } })
+  end
+
+  it "should not match O(1) for a constant augmentation" do
+    @matcher = match_complexity_level('O(1)', lambda { |_| 1 })
+    @matcher.matches?(@test_complexity).should be_false
+  end
+
+  it "should match O(n) for a constant augmentation" do
+    @matcher = match_complexity_level('O(n)', lambda { |n| n })
+    @matcher.matches?(@test_complexity).should be_true
+  end
+
+  context 'when using should' do
+    before :each do
+      @matcher = match_complexity_level('O(1)', lambda { |_| 1 })
+    end
+
+    it "should provide a descriptive error message" do
+      @matcher.matches?(@test_complexity)
+      @matcher.failure_message_for_should.should =~ /\Aexpected a complexity level of O\(1\)/
+      @matcher.failure_message_for_should.should =~ /got scale: [0-9.]+ min: [0-9.]+/
+      @matcher.failure_message_for_should.should =~ /max: [0-9.]+ avg: [0-9.]+/
+      @matcher.failure_message_for_should.should =~ /total values: [0-9]+ on 1\.\.20\Z/
+    end
+  end
+
+  context 'when using should_not' do
+    before :each do
+      @matcher = match_complexity_level('O(n)', lambda { |n| n })
+    end
+
+    it "should provide a descriptive error message" do
+      @matcher.matches?(@test_complexity)
+      @matcher.failure_message_for_should_not.should =~ /\Aexpected a complexity level over O\(n\)/
+      @matcher.failure_message_for_should_not.should =~ /got scale: [0-9.]+ min: [0-9.]+/
+      @matcher.failure_message_for_should_not.should =~ /max: [0-9.]+ avg: [0-9.]+/
+      @matcher.failure_message_for_should_not.should =~ /total values: [0-9]+ on 1\.\.20\Z/
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'helpers/simulation'
+require File.expand_path('../../lib/big-o.rb', __FILE__)
+require File.expand_path('../../lib/big-o-matchers.rb', __FILE__)
+
+RSpec.configure do |c|
+  c.include BigO
+  c.include BigO::Helpers
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: big-o
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Vincent Bonmalais
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+description: Big-O is a gem which analyse an anonymous function and verify that it
+  follow a specific pattern in its memory usage or its execution time.
+email: vbonmalais@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- big-o.gemspec
+- lib/big-o-matchers.rb
+- lib/big-o.rb
+- lib/big-o/complexity_base.rb
+- lib/big-o/exceptions.rb
+- lib/big-o/matchers/match_complexity_level.rb
+- lib/big-o/space_complexity.rb
+- lib/big-o/time_complexity.rb
+- spec/big-o/complexity_base_spec.rb
+- spec/big-o/space_complexity_spec.rb
+- spec/big-o/time_complexity_spec.rb
+- spec/helpers/simulation.rb
+- spec/matchers/match_complexity_level_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kouno/big-o
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Calculate function complexity (using Big O notation)
+test_files:
+- spec/big-o/complexity_base_spec.rb
+- spec/big-o/space_complexity_spec.rb
+- spec/big-o/time_complexity_spec.rb
+- spec/helpers/simulation.rb
+- spec/matchers/match_complexity_level_spec.rb
+- spec/spec_helper.rb
+has_rdoc: