allotment 1.0.4 → 1.1.0

data/lib/allotment/stopwatch.rb

@@ -1,42 +1,99 @@
-class Allotment
-	class Stopwatch
-		attr_reader :name, :status
-
-		def initialize name = nil
-			@stopwatch  = self.class.uniqe_name
-			@name       = name || @stopwatch
-			@status     = 'running'
-			@start_time = Time.now
-		end
-
-		def start
-			@start_time = Time.now - (@current_time || 0)
-			@status     = 'running'
-		end
-
-		def stop
-			@status       = 'stopped'
-			@current_time = Time.now - @start_time
-		end
-
-		def reset
-			@start_time 	= Time.now
-			@current_time = nil
-		end
-
-		def lap
-			@new_lap = Time.now - (@lap_time || @start_time)
-			@lap_time = Time.now
-			return @new_lap
-		end
-
-		def split
-			Time.now - @start_time
-		end
-
-		private
-		def self.uniqe_name
-			"stopwatch_" + (@id ? @id += 1 : @id = 0).to_s
-		end
-	end
+module Allotment
+  # Stopwatch Class
+  # Strangely enough works just like a stopwatch
+  # @!attribute [r] name
+  #   @return [String] the current name
+  # @!attribute [r] status
+  #   @return [String] the current status (running|stopped)
+  #
+  class Stopwatch
+    attr_reader :name, :status
+
+    # Overwite the obj inspect
+    #
+    def inspect
+      "#<Stopwatch:%s>" % @status
+    end
+
+    # If the stopwatch is not given a name the uniqe_name class method is called
+    # @param name [String] choosen name
+    #
+    def initialize name = self.class.uniqe_name
+      @name    = name
+      @status  = 'stopped'
+      @sw_time = 0
+    end
+
+    # if the stopwatch was previously stopped
+    # then the current time is removed from the current time
+    # this means that it is in effect added to the total time
+    # @return [Allotment::Stopwatch] self
+    #
+    def start
+      if status == 'stopped'
+        @last_start = Time.now
+        @sw_start   = Time.now - @sw_time
+        @status     = 'running'
+      end
+      self
+    end
+
+    # sets the current_time
+    # this is where the start time could be Time.now - current_time
+    # @return [Float] the stopwatch time
+    #
+    def stop
+      if status == 'running'
+        @status    = 'stopped'
+        @last_stop = Time.now
+        @sw_time   = Time.now - @sw_start
+      else
+        time
+      end
+    end
+
+    # sets all times to 0
+    # if the timer is running then the start time is just overwritten
+    # if the timer is not then the start time will be over written on start
+    # @return [Allotment::Stopwatch] self
+    #
+    def reset
+      @sw_start = Time.now
+      @sw_time  = 0
+      self
+    end
+
+    # A lap is the amount of time from the very start or from the end of the last lap
+    # Accumilated lap time is retained accross any stopages of the stopwatch
+    # @return [Float] the lap time
+    #
+    def lap
+      new_lap  = time - (@lp_start || 0)
+      @lp_start = time
+      new_lap
+    end
+
+    # A split is the amount of time from the last start of the stopwatch
+    # it uses the sw time so it will keep accumelated time accross stoppages
+    # @return [Float] the split time
+    #
+    def split
+      @status == 'running' ? Time.now - @last_start : @last_stop - @last_start
+    end
+
+    # The accumelated current time on the stopwatch
+    # @return [Float] the current time
+    #
+    def time
+      @status == 'running' ? Time.now - @sw_start : @sw_time
+    end
+
+    private
+
+    # ensures that if a stopwatch is unnamed it has a uniqe name
+    # @return [String] stopwatch uniqe name
+    def self.uniqe_name
+      "stopwatch_" + (@id ? @id += 1 : @id = 0).to_s
+    end
+  end
 end

data/lib/allotment/version.rb

@@ -1,4 +1,6 @@
-class Allotment
-  VERSION = "1.0.4".freeze
-  DATE = "2013-09-02".freeze
+module Allotment
+  # Current Allotment verion
+  VERSION = "1.1.0".freeze
+  # Date version created
+  DATE = "2013-09-24".freeze
 end

data/spec/allotment_spec.rb

@@ -1,139 +1,129 @@
 require 'helper'
 
 describe Allotment do
-  it "is a class" do
-    Allotment.class.should eq Class
+  it "is a module" do
+    Allotment.class.should eq Module
   end
 
-  describe ".record_event" do
-    it "records the time for the block" do
-      Allotment.record_event('my_recording 0.1') { sleep 0.01 }
-    end
-
-    it "records the time for the proc" do
-      Allotment.record_event 'my_recording 0.2' do
-        sleep 0.01
-      end
-    end
-
-    it "returns a float" do
-      result = Allotment.record_event('my_recording 0.3') { sleep 0.01 }
-      result.class.should eq Float
+  describe ".on_start" do
+    it "stores the passed block" do
+      Allotment.on_start { 'test_returned_string' }
+      Allotment.on_start.call.should eq 'test_returned_string'
     end
+  end
 
-    it "returns the execute time of the block" do
-      result = Allotment.record_event('my_recording 0.4') { sleep 0.01 }
-      result.round(2).should eq 0.01
-    end
-
-    it "returns still records the performance upon error" do
-      expect { Allotment.record_event('failed_recording') { sleep 0.01; raise 'error' } }.to raise_error RuntimeError, "error"
-      Allotment.results['failed_recording'].first.round(2).should eq 0.01
+  describe ".on_stop" do
+    it "stores the passed block" do
+      Allotment.on_stop { 'test_returned_string' }
+      Allotment.on_stop.call.should eq 'test_returned_string'
     end
   end
 
-  describe ".start_recording" do
+  describe ".start" do
     it "returns a stopwatch instance" do
-      result = Allotment.start_recording
+      result = Allotment.start
       result.class.should eq Allotment::Stopwatch
     end
 
     it "returns an unnamed stopwatch if no name given" do
-      result = Allotment.start_recording
-      result.name.should eq 'unnamed'
+      result = Allotment.start
+      result.name.should eq 'unnamed_recording'
     end
 
     it "returns a stopwatch with the given name" do
-      result = Allotment.start_recording 'my_recording'
-      result.name.should eq 'my_recording'
+      result = Allotment.start 'my_recording 1.1'
+      result.name.should eq 'my_recording 1.1'
     end
 
     it "returns a stopwatch that is 'running'" do
-      result = Allotment.start_recording
+      result = Allotment.start
       result.status.should eq 'running'
     end
+
+    it "runs the on_start block" do
+      Allotment.on_start { @start_test = 'successful' }
+      @start_test.should eq nil
+      Allotment.start
+      @start_test.should eq 'successful'
+    end
   end
 
-  describe ".stop_recording" do
+  describe ".stop" do
     it "returns a float" do
-      Allotment.start_recording 'my_recording1'
+      Allotment.start 'my_recording 2.1'
       sleep 0.01
-      result = Allotment.stop_recording 'my_recording1'
+      result = Allotment.stop 'my_recording 2.1'
       result.class.should eq Float
     end
 
     it "returns the execute time of the code" do
-      Allotment.start_recording 'my_recording2'
+      Allotment.start 'my_recording 2.2'
       sleep 0.01
-      result = Allotment.stop_recording 'my_recording2'
+      result = Allotment.stop 'my_recording 2.2'
       result.round(2).should eq 0.01
     end
 
     it "raises an error if the recording does not exist" do
-      expect { Allotment.stop_recording 'my_recording3' }.to raise_error NameError, "No recording:my_recording3"
+      expect { Allotment.stop 'my_recording 2.3' }.to raise_error NameError, "Unknown recording:my_recording 2.3"
+    end
+
+    it "runs the on_stop block" do
+      Allotment.start 'my_recording 2.4'
+      Allotment.on_stop { @stop_test = 'successful' }
+      @stop_test.should eq nil
+      Allotment.stop 'my_recording 2.4'
+      @stop_test.should eq 'successful'
     end
   end
 
-  describe ".before" do
-    it "adds a hook to the before hooks array" do
-      hooks = Allotment.before { nil }
-      Allotment._hooks[:before].should eq hooks
+  describe ".record" do
+    it "records the time for the block" do
+      Allotment.record('my_recording 3.1') { sleep 0.01 }
     end
 
-    it "runs the hook before the performance recording" do
-      Allotment.before { @before = Time.now.to_f }
-      Allotment.record_event('before') { @record = Time.now.to_f }
-      @record.should be > Allotment.instance_variable_get("@before")
+    it "records the time for the proc" do
+      Allotment.record 'my_recording 3.2' do
+        sleep 0.01
+      end
+    end
+
+    it "returns a float" do
+      result = Allotment.record('my_recording 3.3') { sleep 0.01 }
+      result.class.should eq Float
     end
-  end
 
-  describe ".after" do
-    it "adds a hook to the after hooks array" do
-      hooks = Allotment.after { nil }
-      Allotment._hooks[:after].should eq hooks
+    it "returns the execute time of the block" do
+      result = Allotment.record('my_recording 3.4') { sleep 0.01 }
+      result.round(2).should eq 0.01
     end
 
-    it "runs the hook after the performance recording" do
-      Allotment.after { @after = Time.now.to_f }
-      Allotment.record_event('after') { @record = Time.now.to_f }
-      @record.should be < Allotment.instance_variable_get("@after")
+    it "returns still records the performance upon error" do
+      expect { Allotment.record('my_recording 3.5') { sleep 0.01; raise 'error' } }.to raise_error RuntimeError, "error"
+      Allotment.results['my_recording 3.5'].first.round(2).should eq 0.01
     end
   end
 
   describe ".results" do
     it "returns a hash" do
-      Allotment.record_event('my_recording4') { sleep 0.01 }
+      Allotment.record('my_recording 4.1') { sleep 0.01 }
       Allotment.results.class.should eq Hashie::Mash
     end
 
     it "returns a hash with the event in" do
-      Allotment.record_event('my_recording5') { sleep 0.01 }
-      Allotment.results.should include('my_recording5')
+      Allotment.record('my_recording 4.2') { sleep 0.01 }
+      Allotment.results.should include('my_recording 4.2')
     end
 
     it "stores the result under the event" do
-      Allotment.record_event('my_recording6') { sleep 0.01 }
-      Allotment.results['my_recording6'][0].round(2).should eq 0.01
+      Allotment.record('my_recording 4.3') { sleep 0.01 }
+      Allotment.results['my_recording 4.3'][0].round(2).should eq 0.01
     end
 
     it "stores each result of each event" do
-      Allotment.record_event('my_recording7') { sleep 0.01 }
-      Allotment.record_event('my_recording7') { sleep 0.02 }
-      Allotment.results['my_recording7'][0].round(2).should eq 0.01
-      Allotment.results['my_recording7'][1].round(2).should eq 0.02
-    end
-  end
-
-  describe ".results_string" do
-    it "returns a string" do
-      Allotment.record_event('my_recording8') { sleep 0.01 }
-      Allotment.results_string.class.should eq String
-    end
-
-    it "returns a string with the event in" do
-      Allotment.record_event('my_recording9') { sleep 0.03 }
-      Allotment.results_string.should include 'my_recording9'
-      Allotment.results_string.should include '0.03'
+      Allotment.record('my_recording 4.4') { sleep 0.01 }
+      Allotment.record('my_recording 4.4') { sleep 0.02 }
+      Allotment.results['my_recording 4.4'][0].round(2).should eq 0.01
+      Allotment.results['my_recording 4.4'][1].round(2).should eq 0.02
     end
   end
 end

data/spec/{stopwatch/array_spec.rb → array_spec.rb}

@@ -1,3 +1,5 @@
+require 'helper'
+
 describe Array do
   describe "#average" do
     it "returns a float" do

data/spec/helper.rb

@@ -1,11 +1,9 @@
 require 'coveralls'
-require 'pry'
-
-require 'allotment'
-require 'allotment/methods'
 
 Coveralls.wear!
 
+require 'allotment'
+
 RSpec.configure do |config|
   config.color_enabled  = true
   config.formatter      = :documentation

data/spec/stopwatch_spec.rb

@@ -0,0 +1,268 @@
+require 'helper'
+
+describe Allotment::Stopwatch do
+  it "is a class" do
+    Allotment::Stopwatch.class.should eq Class
+  end
+
+  describe ".new" do
+    it "returns a class of Stopwatch" do
+      Allotment::Stopwatch.new.class.should eq Allotment::Stopwatch
+    end
+
+    it "sets the stopwatch status to stopped" do
+      Allotment::Stopwatch.new.status.should eq 'stopped'
+    end
+
+    it "gives the stopwatch a name if none given" do
+      Allotment::Stopwatch.new.name.should =~ /stopwatch_\d+/
+    end
+
+    it "sets the name of the stopwatch" do
+      Allotment::Stopwatch.new('stopwatch').name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#inspect" do
+    it "returns the correct inspect string when created" do
+      sw = Allotment::Stopwatch.new
+      sw.inspect.should eq "#<Stopwatch:stopped>"
+    end
+
+    it "returns the correct inspect string when running" do
+      sw = Allotment::Stopwatch.new.start
+      sw.inspect.should eq "#<Stopwatch:running>"
+    end
+
+    it "returns the correct inspect string when stopped" do
+      sw = Allotment::Stopwatch.new.start
+      sw.stop
+      sw.inspect.should eq "#<Stopwatch:stopped>"
+    end
+  end
+
+  describe "#start" do
+    it "returns and instance of self" do
+      Allotment::Stopwatch.new.start.class.should eq Allotment::Stopwatch
+    end
+
+    it "sets the stopwatch status to running" do
+      sw = Allotment::Stopwatch.new.start
+      sw.stop
+      sw.start
+      sw.status.should eq 'running'
+    end
+
+    it "does not change the time when called twice" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.stop.round(2).should eq 0.02
+    end
+
+    it "keeps its stopwatch name" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sw.stop
+      sw.start
+      sw.name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#stop" do
+    it "returns a float" do
+      sw = Allotment::Stopwatch.new.start
+      sw.stop.class.should eq Float
+    end
+
+    it "returns the correct time" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.stop.round(2).should eq 0.01
+    end
+
+    it "keeps track of total time" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.stop
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.stop.round(2).should eq 0.02
+    end
+
+    it "returns the correct time if called twice" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.stop.round(2).should eq 0.01
+      sleep 0.01
+      sw.stop.round(2).should eq 0.01
+    end
+
+    it "sets the stopwatch status to stopped" do
+      sw = Allotment::Stopwatch.new.start
+      sw.stop
+      sw.status.should eq 'stopped'
+    end
+
+    it "keeps its stopwatch name" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sw.stop
+      sw.name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#reset" do
+    it "resets the stopwatch total time when stopped" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.stop
+      sw.reset
+      sw.start
+      sleep 0.01
+      sw.stop.round(2).should eq 0.01
+    end
+
+    it "resets the stopwatch total time when running" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.reset
+      sleep 0.01
+      sw.stop.round(2).should eq 0.01
+    end
+
+    it "should retuen an instance of self" do
+      sw = Allotment::Stopwatch.new
+      sw.reset.class.should eq Allotment::Stopwatch
+    end
+
+    it "keeps its stopwatch name" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sw.reset
+      sw.name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#split" do
+    it "returns a float" do
+      sw = Allotment::Stopwatch.new.start
+      sw.split.class.should eq Float
+    end
+
+    it "returns the correct time" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.split.round(2).should eq 0.01
+      sleep 0.01
+      sw.split.round(2).should eq 0.02
+    end
+
+    it "returns the correct time when stopped" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.02
+      sw.split.round(2).should eq 0.02
+      sw.stop
+      sleep 0.01
+      sw.split.round(2).should eq 0.02
+    end
+
+    it "returns the time from the last start" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.split.round(2).should eq 0.01
+      sw.stop
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.split.round(2).should eq 0.01
+    end
+
+    it "keeps its stopwatch name" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sw.split
+      sw.name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#lap" do
+    it "returns a float" do
+      sw = Allotment::Stopwatch.new.start
+      sw.lap.class.should eq Float
+    end
+
+    it "returns the correct time" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+    end
+
+    it "returns the correct time over stop/start" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+      sw.stop
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+    end
+
+    it "returns the correct time when stopped" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+      sleep 0.01
+      sw.stop
+      sleep 0.01
+      sw.lap.round(2).should eq 0.01
+    end
+
+    it "keeps its stopwatch name" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sw.lap
+      sw.name.should eq 'stopwatch'
+    end
+  end
+
+  describe "#time" do
+    it "displays the current time while running" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sleep 0.01
+      sw.time.round(2).should eq 0.01
+      sleep 0.01
+      sw.time.round(2).should eq 0.02
+    end
+
+    it "displays the current time while stopped" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sleep 0.01
+      sw.time.round(2).should eq 0.01
+      sw.stop
+      sleep 0.01
+      sw.time.round(2).should eq 0.01
+    end
+
+    it "returns the correct time over stop/start" do
+      sw = Allotment::Stopwatch.new.start
+      sleep 0.01
+      sw.stop
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.time.round(2).should eq 0.02
+    end
+
+    it "displays the current time when the stopwatch has been restarted" do
+      sw = Allotment::Stopwatch.new('stopwatch').start
+      sleep 0.01
+      sw.stop
+      sw.time.round(2).should eq 0.01
+      sleep 0.01
+      sw.start
+      sleep 0.01
+      sw.time.round(2).should eq 0.02
+    end
+  end
+end