big-o 0.1 → 0.1.1

data/README.md

@@ -45,7 +45,9 @@ space_complexity = BigO::SpaceComplexity({
   :timeout => 10,                 # time in seconds
   :approximation => 0.05,         # percentage
   :error_pct => 0.05,             # percentage
-  :minimum_result_set_size => 3   # minimum results
+  :minimum_result_set_size => 3,  # minimum results
+  :after_hook => proc { },        # See before/after hooks
+  :before_hook => proc { }
 })
 ```
 
@@ -60,7 +62,7 @@ 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) }
+      :fn => lambda { |n| do_something_time_consuming(n) }
     })
   end
 
@@ -69,7 +71,7 @@ describe 'do_something_time_consuming' do
   end
 
   it 'should not have a complexity of O(1)' do
-    @time_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+    @time_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
   end
 end
 ```
@@ -77,6 +79,28 @@ end
 The string used as the first parameter (e.g. `'O(n)'`) is used to describe the lambda given as the
 second parameter.
 
+### After/Before hooks
+
+Your function depends on something which needs to run before every call of your function? You need to
+cleanup whatever dirty work your function performed? These operation are time/space consuming and they will
+affect the values of your function? Well, just throw these things in the before/after hooks!
+
+```ruby
+time_complexity = BigO::TimeComplexity({
+  :fn    => lambda { |_| whatever_action_which_doesnt_depend_on_n },
+  :level => lambda { |n| n**2 },
+  :before_hook => lambda { |n| prepare_fn_environment(n) },
+  :after_hook => lambda { |n| clean_up(n) }
+})
+time_complexity.process # will only time :fn
+```
+
+Warning: The timeout is still in effect during before and after hooks execution (in our example, it may stop
+during clean_up). There should not be any sensitive code which needs to be executed in before/after hooks.
+
+If you need to cleanup something after `time_complexity.process`, you will prefer to place this code out of :after_hook 
+or :before_hook.
+
 ## Reference
 
 You may want to read more on the subject by reading:

data/big-o.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'big-o'
-  s.version     = '0.1'
-  s.date        = '2012-07-25'
+  s.version     = '0.1.1'
+  s.date        = '2012-07-27'
   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."

data/lib/big-o/complexity_base.rb

@@ -34,7 +34,9 @@ module BigO
                    :timeout => 10,
                    :approximation => 0.05,
                    :error_pct => 0.05,
-                   :minimum_result_set_size => 3 }
+                   :minimum_result_set_size => 3,
+                   :before_hook => proc {},
+                   :after_hook => proc {} }
 
       @options.merge!(options)
     end
@@ -63,7 +65,7 @@ module BigO
       begin
         Timeout::timeout(@options[:timeout]) do
           @options[:range].each do |n|
-            next if (indicator = measure(n, &@options[:fn])) == 0
+            next if (indicator = measurement(n)) == 0
             real_complexity[n]     = indicator
             expected_complexity[n] = @options[:level].call(n)
           end
@@ -78,6 +80,22 @@ module BigO
       [real_complexity, expected_complexity]
     end
 
+    # Measurement process.
+    #
+    # Composed of the measurement itself and executing two hooks :before_hook and :after_hook.
+    # Due to the structure of the measurement, the hooks are not (and should not) be part of the
+    # measure. In other words, any code executed within :before_hook or :after_hook will not affect
+    # the time/space measure of :fn.
+    #
+    # @param [Integer] n iteration
+    # @return [Float] indicator
+    def measurement(n)
+      @options[:before_hook].call(n)
+      indicator = measure(n, &@options[:fn])
+      @options[:after_hook].call(n)
+      indicator
+    end
+
     # Parses data from <code>#run_simulation</code>.
     #
     # <code>examine_result_set</code> will return true only if these conditions are met:

data/spec/big-o/complexity_base_spec.rb

@@ -6,7 +6,7 @@ describe ComplexityBase do
     class FunctionComplexity
       include ComplexityBase
 
-      def measure
+      def measure(*args, &b)
         1
       end
     end
@@ -55,4 +55,23 @@ describe ComplexityBase do
       @fn_complexity.options[:approximation].should == 0.1
     end
   end
+
+  describe 'before/after hooks' do
+    before :each do
+      @after_hook    = double('lambda')
+      @before_hook   = double('lambda')
+      @fn_complexity = FunctionComplexity.new({
+          :fn => lambda { |_| 1 },
+          :level => lambda { |_| 1},
+          :before_hook => @before_hook,
+          :after_hook => @after_hook })
+
+    end
+
+    it 'should be called every time we try to match a complexity level' do
+      @before_hook.should_receive(:call).with(kind_of(Integer)).at_most(20).times
+      @after_hook.should_receive(:call).with(kind_of(Integer)).at_most(20).times
+      @fn_complexity.process
+    end
+  end
 end

data/spec/big-o/space_complexity_spec.rb

@@ -12,6 +12,14 @@ describe SpaceComplexity do
     lambda { @space_complexity.process }.should raise_error(Timeout::Error)
   end
 
+  it 'should ignore whatever is happening in a before/after hook' do
+    @space_complexity.options[:fn] = lambda { |_| simulate_memory_space(1024) }
+    @space_complexity.options[:before_hook] = lambda { |n| simulate_memory_space(1024 * n) }
+    @space_complexity.options[:after_hook] = lambda { |n| simulate_memory_space(1024 * n) }
+    @space_complexity.options[:approximation] = 0.2
+    @space_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+  end
+
   describe '#process on complexity O(1)' do
     before :each do
       @space_complexity.options[:fn] = lambda { |_| simulate_memory_space(1024) }
@@ -35,7 +43,6 @@ describe SpaceComplexity do
     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

data/spec/big-o/time_complexity_spec.rb

@@ -6,15 +6,27 @@ describe TimeComplexity do
     @time_complexity = TimeComplexity.new
   end
 
+  MIN_TIME = 0.01
+  AVG_TIME = 0.05
+
   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
 
+  it 'should ignore whatever is happening in a before/after hook' do
+    @time_complexity.options[:fn] = lambda { |_| simulate_utime_processing(MIN_TIME) }
+    @time_complexity.options[:before_hook] = lambda { |n| simulate_utime_processing(MIN_TIME * n) }
+    @time_complexity.options[:after_hook] = lambda { |n| simulate_utime_processing(MIN_TIME * n) }
+    @time_complexity.options[:approximation] = 0.2
+    @time_complexity.should match_complexity_level 'O(1)', lambda { |_| 1 }
+  end
+
+
   describe '#process on complexity O(1)' do
     before :each do
-      @time_complexity.options[:fn] = lambda { |_| simulate_utime_processing(0.5) }
+      @time_complexity.options[:fn] = lambda { |_| simulate_utime_processing(AVG_TIME) }
     end
 
     it 'should run the function and produce a report when time threshold is hit' do
@@ -25,7 +37,7 @@ describe TimeComplexity do
 
   describe '#process on complexity O(n)' do
     before :each do
-      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(0.5 * n) }
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(AVG_TIME * n) }
     end
 
     it 'should run the function and produce a report when time threshold is hit' do
@@ -36,7 +48,7 @@ describe TimeComplexity do
   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)) }
+      @time_complexity.options[:fn] = lambda { |n| simulate_utime_processing(AVG_TIME * (n**2)) }
     end
 
     it 'should run the function and produce a report when time threshold is hit' do
@@ -51,14 +63,14 @@ describe TimeComplexity do
 
   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.options[:fn] = lambda { |n| simulate_utime_processing(MIN_TIME * 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.options[:fn] = lambda { |n| simulate_utime_processing(MIN_TIME * n) }
       @time_complexity.should     match_complexity_level 'O(n)', lambda { |n| n }
       @time_complexity.should_not match_complexity_level 'O(1)', lambda { |_| 1 }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: big-o
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-25 00:00:00.000000000 Z
+date: 2012-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec