one_inch_punch 0.2.2 → 0.2.3

data/spec/punch_instance_spec.rb

@@ -1,18 +1,18 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Punch, 'instance' do
-  before :each do
+  before do
     @project = 'proj'
     @punch = Punch.new(@project)
   end
   
   describe 'when initialized' do
     it 'should accept a project' do
-      lambda { Punch.new(@project) }.should_not raise_error(ArgumentError)
+      lambda { Punch.new(@project) }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project' do
-      lambda { Punch.new }.should raise_error(ArgumentError)
+      lambda { Punch.new }.should.raise(ArgumentError)
     end
     
     it 'should save the project for later use' do
@@ -21,22 +21,22 @@ describe Punch, 'instance' do
   end
   
   it 'should give project status' do
-    @punch.should respond_to(:status)
+    @punch.should.respond_to(:status)
   end
   
   describe 'giving project status' do
-    before :each do
+    before do
       @status = 'status val'
-      Punch.stubs(:status).returns(@status)
+      Punch.stub!(:status).and_return(@status)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:status)
+      Punch.should.receive(:status)
       @punch.status
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:status).with(@project)
+      Punch.should.receive(:status).with(@project)
       @punch.status
     end
     
@@ -46,22 +46,22 @@ describe Punch, 'instance' do
   end
   
   it 'should indicate whether the project is punched out' do
-    @punch.should respond_to(:out?)
+    @punch.should.respond_to(:out?)
   end
   
   describe 'indicating whether the project is punched out' do
-    before :each do
+    before do
       @out = 'out val'
-      Punch.stubs(:out?).returns(@out)
+      Punch.stub!(:out?).and_return(@out)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:out?)
+      Punch.should.receive(:out?)
       @punch.out?
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:out?).with(@project)
+      Punch.should.receive(:out?).with(@project)
       @punch.out?
     end
     
@@ -71,22 +71,22 @@ describe Punch, 'instance' do
   end
   
   it 'should indicate whether the project is punched in' do
-    @punch.should respond_to(:in?)
+    @punch.should.respond_to(:in?)
   end
   
   describe 'indicating whether the project is punched in' do
-    before :each do
+    before do
       @in = 'in val'
-      Punch.stubs(:in?).returns(@in)
+      Punch.stub!(:in?).and_return(@in)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:in?)
+      Punch.should.receive(:in?)
       @punch.in?
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:in?).with(@project)
+      Punch.should.receive(:in?).with(@project)
       @punch.in?
     end
     
@@ -96,41 +96,47 @@ describe Punch, 'instance' do
   end
   
   it 'should punch the project in' do
-    @punch.should respond_to(:in)
+    @punch.should.respond_to(:in)
   end
   
   describe 'punching the project in' do
-    before :each do
+    before do
       @in = 'in val'
-      Punch.stubs(:in).returns(@in)
+      Punch.stub!(:in).and_return(@in)
     end
     
     it 'should accept options' do
-      lambda { @punch.in(:time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { @punch.in(:time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { @punch.in }.should_not raise_error(ArgumentError)
+      lambda { @punch.in }.should.not.raise(ArgumentError)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:in)
+      Punch.should.receive(:in)
       @punch.in
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:in).with(@project, anything)
+      Punch.should.receive(:in) do |proj, _|
+        proj.should == @project
+      end
       @punch.in
     end
     
     it 'should pass the options when delegating to the class' do
       options = { :time => Time.now }
-      Punch.expects(:in).with(anything, options)
+      Punch.should.receive(:in) do |_, opts|
+        opts.should == options
+      end
       @punch.in(options)
     end
     
     it 'should pass an empty hash if no options given' do
-      Punch.expects(:in).with(anything, {})
+      Punch.should.receive(:in) do |_, opts|
+        opts.should == {}
+      end
       @punch.in
     end
     
@@ -140,41 +146,47 @@ describe Punch, 'instance' do
   end
   
   it 'should punch the project out' do
-    @punch.should respond_to(:out)
+    @punch.should.respond_to(:out)
   end
   
   describe 'punching the project out' do
-    before :each do
+    before do
       @out = 'out val'
-      Punch.stubs(:out).returns(@out)
+      Punch.stub!(:out).and_return(@out)
     end
     
     it 'should accept options' do
-      lambda { @punch.out(:time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { @punch.out(:time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { @punch.out }.should_not raise_error(ArgumentError)
+      lambda { @punch.out }.should.not.raise(ArgumentError)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:out)
+      Punch.should.receive(:out)
       @punch.out
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:out).with(@project, anything)
+      Punch.should.receive(:out) do |proj, _|
+        proj.should == @project
+      end
       @punch.out
     end
     
     it 'should pass the options when delegating to the class' do
       options = { :time => Time.now }
-      Punch.expects(:out).with(anything, options)
+      Punch.should.receive(:out) do |_, opts|
+        opts.should == options
+      end
       @punch.out(options)
     end
     
     it 'should pass an empty hash if no options given' do
-      Punch.expects(:out).with(anything, {})
+      Punch.should.receive(:out) do |_, opts|
+        opts.should == {}
+      end
       @punch.out
     end
     
@@ -184,41 +196,47 @@ describe Punch, 'instance' do
   end
   
   it 'should list the project data' do
-    @punch.should respond_to(:list)
+    @punch.should.respond_to(:list)
   end
   
   describe 'listing the project data' do
-    before :each do
+    before do
       @list = 'list val'
-      Punch.stubs(:list).returns(@list)
+      Punch.stub!(:list).and_return(@list)
     end
     
     it 'should accept options' do
-      lambda { @punch.list(:time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { @punch.list(:time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { @punch.list }.should_not raise_error(ArgumentError)
+      lambda { @punch.list }.should.not.raise(ArgumentError)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:list)
+      Punch.should.receive(:list)
       @punch.list
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:list).with(@project, anything)
+      Punch.should.receive(:list) do |proj, _|
+        proj.should == @project
+      end
       @punch.list
     end
     
     it 'should pass the options when delegating to the class' do
       options = { :time => Time.now }
-      Punch.expects(:list).with(anything, options)
+      Punch.should.receive(:list) do |_, opts|
+        opts.should == options
+      end
       @punch.list(options)
     end
     
     it 'should pass an empty hash if no options given' do
-      Punch.expects(:list).with(anything, {})
+      Punch.should.receive(:list) do |_, opts|
+        opts.should == {}
+      end
       @punch.list
     end
     
@@ -228,41 +246,47 @@ describe Punch, 'instance' do
   end
   
   it 'should get the project total' do
-    @punch.should respond_to(:total)
+    @punch.should.respond_to(:total)
   end
   
   describe 'getting the project total' do
-    before :each do
+    before do
       @total = 'total val'
-      Punch.stubs(:total).returns(@total)
+      Punch.stub!(:total).and_return(@total)
     end
     
     it 'should accept options' do
-      lambda { @punch.total(:time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { @punch.total(:time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { @punch.total }.should_not raise_error(ArgumentError)
+      lambda { @punch.total }.should.not.raise(ArgumentError)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:total)
+      Punch.should.receive(:total)
       @punch.total
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:total).with(@project, anything)
+      Punch.should.receive(:total) do |proj, _|
+        proj.should == @project
+      end
       @punch.total
     end
     
     it 'should pass the options when delegating to the class' do
       options = { :time => Time.now }
-      Punch.expects(:total).with(anything, options)
+      Punch.should.receive(:total) do |_, opts|
+        opts.should == options
+      end
       @punch.total(options)
     end
     
     it 'should pass an empty hash if no options given' do
-      Punch.expects(:total).with(anything, {})
+      Punch.should.receive(:total) do |_, opts|
+        opts.should == {}
+      end
       @punch.total
     end
     
@@ -272,36 +296,59 @@ describe Punch, 'instance' do
   end
   
   it 'should log information about the project' do
-    @punch.should respond_to(:log)
+    @punch.should.respond_to(:log)
   end
   
   describe 'logging information about the project' do
-    before :each do
+    before do
       @log = 'log val'
       @message = 'some log message'
-      Punch.stubs(:log).returns(@log)
+      Punch.stub!(:log).and_return(@log)
     end
     
     it 'should accept a log message' do
-      lambda { @punch.log(@message) }.should_not raise_error(ArgumentError)
+      lambda { @punch.log(@message) }.should.not.raise(ArgumentError)
     end
     
     it 'should require a log message' do
-      lambda { @punch.log }.should raise_error(ArgumentError)
+      lambda { @punch.log }.should.raise(ArgumentError)
+    end
+    
+    it 'should accept options' do
+      lambda { @punch.log(@message, :time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should delegate to the class' do
-      Punch.expects(:log)
+      Punch.should.receive(:log)
       @punch.log(@message)
     end
     
     it 'should pass the project when delegating to the class' do
-      Punch.expects(:log).with(@project, anything)
+      Punch.should.receive(:log) do |proj, _, _|
+        proj.should == @project
+      end
       @punch.log(@message)
     end
     
     it 'should pass the message when delegating to the class' do
-      Punch.expects(:log).with(anything, @message)
+      Punch.should.receive(:log) do |_, msg, _|
+        msg.should == @message
+      end
+      @punch.log(@message)
+    end
+    
+    it 'should pass the options when delegating to the class' do
+      options = { :time => Time.now }
+      Punch.should.receive(:log) do |_, _, opts|
+        opts.should == options
+      end
+      @punch.log(@message, options)
+    end
+    
+    it 'should pass an empty hash if no options given' do
+      Punch.should.receive(:log) do |_, _, opts|
+        opts.should == {}
+      end
       @punch.log(@message)
     end
     

data/spec/punch_spec.rb

@@ -2,11 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Punch do
   it 'should load data' do
-    Punch.should respond_to(:load)
+    Punch.should.respond_to(:load)
   end
   
   describe 'when loading data' do
-    before :each do
+    before do
       @data = <<-EOD
       ---
       rip: 
@@ -30,7 +30,7 @@ describe Punch do
         total: "00:55:17"
         in: 2008-05-19T11:23:35.00-05:00
       EOD
-      File.stubs(:read).returns(@data)
+      File.stub!(:read).and_return(@data)
       
       Punch.instance_eval do
         class << self
@@ -42,7 +42,7 @@ describe Punch do
     end
     
     it 'should read the ~/.punch.yml file' do
-      File.expects(:read).with(File.expand_path('~/.punch.yml')).returns(@data)
+      File.should.receive(:read).with(File.expand_path('~/.punch.yml')).and_return(@data)
       Punch.load
     end
     
@@ -57,11 +57,11 @@ describe Punch do
       end
       
       describe 'and is empty' do
-        before :each do
-          File.stubs(:read).returns('')
+        before do
+          File.stub!(:read).and_return('')
         end
         
-        it 'should load the data as yaml' do
+        it 'should set the data to an empty hash' do
           Punch.load
           Punch.data.should == {}
         end
@@ -73,8 +73,8 @@ describe Punch do
     end
     
     describe 'when no file is found' do
-      before :each do
-        File.stubs(:read).raises(Errno::ENOENT)
+      before do
+        File.stub!(:read).and_raise(Errno::ENOENT)
       end
       
       it 'should set the data to an empty hash' do
@@ -82,7 +82,7 @@ describe Punch do
         Punch.data.should == {}
       end
       
-      it 'should return false' do
+      it 'should return true' do
         Punch.load.should == true
       end
     end
@@ -102,14 +102,14 @@ describe Punch do
   end
   
   it 'should reset itself' do
-    Punch.should respond_to(:reset)
+    Punch.should.respond_to(:reset)
   end
   
   describe 'when resetting itself' do
-    before :each do
+    before do
       Punch.instance_eval do
         class << self
-          public :data, :data=
+          public :data=
         end
       end
     end
@@ -117,18 +117,18 @@ describe Punch do
     it 'should set its data to nil' do
       Punch.data = { 'proj' => 'lots of stuff here' }
       Punch.reset
-      Punch.instance_variable_get('@data').should be_nil
+      Punch.instance_variable_get('@data').should.be.nil
     end
   end
   
   it 'should write data' do
-    Punch.should respond_to(:write)
+    Punch.should.respond_to(:write)
   end
   
   describe 'when writing data' do
-    before :each do
-      @file = stub('file')
-      File.stubs(:open).yields(@file)
+    before do
+      @file = mock('file')
+      File.stub!(:open).and_yield(@file)
       @data = { 'proj' => 'data goes here' }
       
       Punch.instance_eval do
@@ -140,22 +140,22 @@ describe Punch do
     end
     
     it 'should open the data file for writing' do
-      File.expects(:open).with(File.expand_path('~/.punch.yml'), 'w')
+      File.should.receive(:open).with(File.expand_path('~/.punch.yml'), 'w')
       Punch.write
     end
     
     it 'should write the data to the file in YAML form' do
-      @file.expects(:puts).with(@data.to_yaml)
+      @file.should.receive(:puts).with(@data.to_yaml)
       Punch.write
     end
   end
   
   it 'should give project status' do
-    Punch.should respond_to(:status)
+    Punch.should.respond_to(:status)
   end
   
   describe "giving a project's status" do
-    before :each do
+    before do
       @now = Time.now
       @projects = { 'out' => 'test-o', 'in' => 'testshank' }
       @data = { 
@@ -172,11 +172,11 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.status('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.status('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should not require a project name' do
-      lambda { Punch.status }.should_not raise_error(ArgumentError)
+      lambda { Punch.status }.should.not.raise(ArgumentError)
     end
     
     it "should return 'out' if the project is currently punched out" do
@@ -188,14 +188,14 @@ describe Punch do
     end
     
     it 'should return nil if the project does not exist' do
-      Punch.status('other project').should be_nil
+      Punch.status('other project').should.be.nil
     end
     
     it 'should return nil if the project has no time data' do
       project = 'empty project'
       @data[project] = []
       Punch.data = @data
-      Punch.status(project).should be_nil
+      Punch.status(project).should.be.nil
     end
     
     it 'should use the last time entry for the status' do
@@ -213,89 +213,89 @@ describe Punch do
   end
   
   it 'should indicate whether a project is punched out' do
-    Punch.should respond_to(:out?)
+    Punch.should.respond_to(:out?)
   end
   
   describe 'indicating whether a project is punched out' do
-    before :each do
+    before do
       @project = 'testola'
     end
     
     it 'should accept a project name' do
-      lambda { Punch.out?('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.out?('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project name' do
-      lambda { Punch.out? }.should raise_error(ArgumentError)
+      lambda { Punch.out? }.should.raise(ArgumentError)
     end
         
     it "should get the project's status" do
-      Punch.expects(:status).with(@project)
+      Punch.should.receive(:status).with(@project)
       Punch.out?(@project)
     end
     
     it "should return true if the project's status is 'out'" do
-      Punch.stubs(:status).returns('out')
+      Punch.stub!(:status).and_return('out')
       Punch.out?(@project).should == true
     end
     
     it "should return false if the project's status is 'in'" do
-      Punch.stubs(:status).returns('in')
+      Punch.stub!(:status).and_return('in')
       Punch.out?(@project).should == false
     end
     
     it "should return true if the project's status is nil" do
-      Punch.stubs(:status).returns(nil)
+      Punch.stub!(:status).and_return(nil)
       Punch.out?(@project).should == true
     end
   end
   
   it 'should indicate whether a project is punched in' do
-    Punch.should respond_to(:in?)
+    Punch.should.respond_to(:in?)
   end
   
   describe 'indicating whether a project is punched in' do
-    before :each do
+    before do
       @project = 'testola'
     end
     
     it 'should accept a project name' do
-      lambda { Punch.in?('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.in?('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project name' do
-      lambda { Punch.in? }.should raise_error(ArgumentError)
+      lambda { Punch.in? }.should.raise(ArgumentError)
     end
         
     it "should get the project's status" do
-      Punch.expects(:status).with(@project)
+      Punch.should.receive(:status).with(@project)
       Punch.in?(@project)
     end
     
     it "should return false if the project's status is 'out'" do
-      Punch.stubs(:status).returns('out')
+      Punch.stub!(:status).and_return('out')
       Punch.in?(@project).should == false
     end
     
     it "should return true if the project's status is 'in'" do
-      Punch.stubs(:status).returns('in')
+      Punch.stub!(:status).and_return('in')
       Punch.in?(@project).should == true
     end
     
     it "should return false if the project's status is nil" do
-      Punch.stubs(:status).returns(nil)
+      Punch.stub!(:status).and_return(nil)
       Punch.in?(@project).should == false
     end
   end
   
   it 'should punch a project in' do
-    Punch.should respond_to(:in)
+    Punch.should.respond_to(:in)
   end
   
   describe 'punching a project in' do
-    before :each do
+    before do
       @now = Time.now
-      Time.stubs(:now).returns(@now)
+      Time.stub!(:now).and_return(@now)
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25} ] }
       
@@ -308,19 +308,19 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.in('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.in('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project name' do
-      lambda { Punch.in }.should raise_error(ArgumentError)
+      lambda { Punch.in }.should.raise(ArgumentError)
     end
     
     it 'should accept options' do
-      lambda { Punch.in('proj', :time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Punch.in('proj', :time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     describe 'when the project is already punched in' do
-      before :each do
+      before do
         @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25}, {'in' => @now - 5} ] }
         Punch.data = @data
       end
@@ -348,8 +348,7 @@ describe Punch do
       end
       
       it 'should log a message about punch-in time' do
-        time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch in @ #{time}")
+        Punch.should.receive(:log).with(@project, 'punch in', :time => @now)
         Punch.in(@project)
       end
       
@@ -361,19 +360,26 @@ describe Punch do
       
       it 'should log a message using the given time' do
         time = @now + 75
-        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch in @ #{time_str}")
+        Punch.should.receive(:log).with(@project, 'punch in', :time => time)
         Punch.in(@project, :time => time)
       end
       
       it 'should log an additional message if given' do
-        Punch.stubs(:log)  # for the time-based message
+        Punch.stub!(:log)  # for the time-based message
         message = 'working on some stuff'
-        Punch.expects(:log).with(@project, message)
+        Punch.should.receive(:log).with(@project, message, :time => @now)
         Punch.in(@project, :message => message)
       end
       
-      it "should allow the different time to be specified using :at" do
+      it 'should log the additional message with the given time' do
+        Punch.stub!(:log)  # for the time-based message
+        time = @now + 75
+        message = 'working on some stuff'
+        Punch.should.receive(:log).with(@project, message, :time => time)
+        Punch.in(@project, :message => message, :time => time)
+      end
+      
+      it 'should allow the different time to be specified using :at' do
         time = @now + 50
         Punch.in(@project, :at => time)
         Punch.data[@project].last['in'].should == time
@@ -385,13 +391,13 @@ describe Punch do
     end
     
     describe 'when the project does not yet exist' do
-      before :each do
+      before do
         @project = 'non-existent project'
       end
       
       it 'should create the project' do
         Punch.in(@project)
-        Punch.data.should have_key(@project)
+        Punch.data.should.include(@project)
       end
       
       it 'should add a time entry to the project data' do
@@ -405,8 +411,7 @@ describe Punch do
       end
       
       it 'should log a message about punch-in time' do
-        time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch in @ #{time}")
+        Punch.should.receive(:log).with(@project, 'punch in', :time => @now)
         Punch.in(@project)
       end
       
@@ -418,11 +423,31 @@ describe Punch do
       
       it 'should log a message using the given time' do
         time = @now + 75
-        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch in @ #{time_str}")
+        Punch.should.receive(:log).with(@project, 'punch in', :time => time)
         Punch.in(@project, :time => time)
       end
       
+      it 'should log an additional message if given' do
+        Punch.stub!(:log)  # for the time-based message
+        message = 'working on some stuff'
+        Punch.should.receive(:log).with(@project, message, :time => @now)
+        Punch.in(@project, :message => message)
+      end
+      
+      it 'should log the additional message with the given time' do
+        Punch.stub!(:log)  # for the time-based message
+        time = @now + 75
+        message = 'working on some stuff'
+        Punch.should.receive(:log).with(@project, message, :time => time)
+        Punch.in(@project, :message => message, :time => time)
+      end
+      
+      it 'should allow the different time to be specified using :at' do
+        time = @now + 50
+        Punch.in(@project, :at => time)
+        Punch.data[@project].last['in'].should == time
+      end
+      
       it 'should return true' do
         Punch.in(@project).should == true
       end
@@ -430,13 +455,13 @@ describe Punch do
   end
   
   it 'should punch a project out' do
-    Punch.should respond_to(:out)
+    Punch.should.respond_to(:out)
   end
   
   describe 'punching a project out' do
-    before :each do
+    before do
       @now = Time.now
-      Time.stubs(:now).returns(@now)
+      Time.stub!(:now).and_return(@now)
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25} ] }
       
@@ -449,19 +474,19 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.out('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.out('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should not require a project name' do
-      lambda { Punch.out }.should_not raise_error(ArgumentError)
+      lambda { Punch.out }.should.not.raise(ArgumentError)
     end
     
     it 'should accept a project name and options' do
-      lambda { Punch.out('proj', :time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Punch.out('proj', :time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should accept options without a project name' do
-      lambda { Punch.out(:time => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Punch.out(:time => Time.now) }.should.not.raise(ArgumentError)
     end
     
     describe 'when the project is already punched out' do
@@ -477,7 +502,7 @@ describe Punch do
     end
     
     describe 'when the project is not already punched out' do
-      before :each do
+      before do
         @data = { @project => [ {'in' => @now - 50} ] }
         Punch.data = @data
       end
@@ -493,8 +518,7 @@ describe Punch do
       end
       
       it 'should log a message about punch-out time' do
-        time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch out @ #{time}")
+        Punch.should.receive(:log).with(@project, 'punch out', :time => @now)
         Punch.out(@project)
       end
       
@@ -506,19 +530,26 @@ describe Punch do
       
       it 'should log a message using the given time' do
         time = @now + 75
-        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@project, "punch out @ #{time_str}")
+        Punch.should.receive(:log).with(@project, 'punch out', :time => time)
         Punch.out(@project, :time => time)
       end
       
       it 'should log an additional message if given' do
-        Punch.stubs(:log)  # for the time-based message
+        Punch.stub!(:log)  # for the time-based message
         message = 'finished working on some stuff'
-        Punch.expects(:log).with(@project, message)
+        Punch.should.receive(:log).with(@project, message, :time => @now)
         Punch.out(@project, :message => message)
       end
       
-      it "should allow the different time to be specified using :at" do
+      it 'should log the additional message with the given time' do
+        Punch.stub!(:log)  # for the time-based message
+        time = @now + 75
+        message = 'working on some stuff'
+        Punch.should.receive(:log).with(@project, message, :time => time)
+        Punch.out(@project, :message => message, :time => time)
+      end
+      
+      it 'should allow the different time to be specified using :at' do
         time = @now + 50
         Punch.out(@project, :at => time)
         Punch.data[@project].last['out'].should == time
@@ -530,7 +561,7 @@ describe Punch do
     end
     
     describe 'when no project is given' do
-      before :each do
+      before do
         @projects = ['test project', 'out project', 'other project']
         @data = {
           @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
@@ -549,8 +580,8 @@ describe Punch do
       
       it 'should log punch-out messages for all projects being punched out' do
         time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@projects[1], "punch out @ #{time}")
-        Punch.expects(:log).with(@projects[2], "punch out @ #{time}")
+        Punch.should.receive(:log).with(@projects[1], 'punch out', :time => @now)
+        Punch.should.receive(:log).with(@projects[2], 'punch out', :time => @now)
         Punch.out
       end
       
@@ -564,26 +595,33 @@ describe Punch do
       
       it 'should log messages using the given time' do
         time = @now + 75
-        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
-        Punch.expects(:log).with(@projects[1], "punch out @ #{time_str}")
-        Punch.expects(:log).with(@projects[2], "punch out @ #{time_str}")
+        Punch.should.receive(:log).with(@projects[1], 'punch out', :time => time)
+        Punch.should.receive(:log).with(@projects[2], 'punch out', :time => time)
         Punch.out(:time => time)
       end
       
       it 'should log an additional message if given' do
-        Punch.stubs(:log)  # for the time-based messages
+        Punch.stub!(:log)  # for the time-based messages
         message = 'finished working on some stuff'
-        Punch.expects(:log).with(@projects[1], message)
-        Punch.expects(:log).with(@projects[2], message)
+        Punch.should.receive(:log).with(@projects[1], message, :time => @now)
+        Punch.should.receive(:log).with(@projects[2], message, :time => @now)
         Punch.out(:message => message)
       end
       
+      it 'should allow the different time to be specified using :at' do
+        time = @now + 50
+        Punch.out(:at => time)
+        Punch.data[@projects[0]].last['out'].should == @now - 25
+        Punch.data[@projects[1]].last['out'].should == time
+        Punch.data[@projects[2]].last['out'].should == time
+      end
+      
       it 'should return true' do
         Punch.out.should == true
       end
       
       describe 'when all projects were already punched out' do
-        before :each do
+        before do
           @projects = ['test project', 'out project', 'other project']
           @data = {
             @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
@@ -607,11 +645,11 @@ describe Punch do
   end
 
   it 'should delete a project' do
-    Punch.should respond_to(:delete)
+    Punch.should.respond_to(:delete)
   end
   
   describe 'deleting a project' do
-    before :each do
+    before do
       @now = Time.now
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25} ] }
@@ -625,17 +663,17 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.delete('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.delete('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project name' do
-      lambda { Punch.delete }.should raise_error(ArgumentError)
+      lambda { Punch.delete }.should.raise(ArgumentError)
     end
     
     describe 'when the project exists' do
       it 'should remove the project data' do
         Punch.delete(@project)
-        Punch.data.should_not have_key(@project)
+        Punch.data.should.not.include(@project)
       end
       
       it 'should return true' do
@@ -644,22 +682,22 @@ describe Punch do
     end
     
     describe 'when the project does not exist' do
-      before :each do
+      before do
         @project = 'non-existent project'
       end
       
       it 'should return nil' do
-        Punch.delete(@project).should be_nil
+        Punch.delete(@project).should.be.nil
       end
     end
   end
   
   it 'should list project data' do
-    Punch.should respond_to(:list)
+    Punch.should.respond_to(:list)
   end
   
   describe 'listing project data' do
-    before :each do
+    before do
       @now = Time.now
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 5000, 'out' => @now - 2500}, {'in' => @now - 2000, 'out' => @now - 1000}, {'in' => @now - 500, 'out' => @now - 100} ] }
@@ -673,15 +711,15 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.list('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.list('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should not require a project name' do
-      lambda { Punch.list }.should_not raise_error(ArgumentError)
+      lambda { Punch.list }.should.not.raise(ArgumentError)
     end
     
     it 'should allow options' do
-      lambda { Punch.list('proj', :after => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Punch.list('proj', :after => Time.now) }.should.not.raise(ArgumentError)
     end
     
     describe 'when the project exists' do
@@ -702,7 +740,7 @@ describe Punch do
       end
       
       describe 'and is punched in' do
-        before :each do
+        before do
           @data[@project].push({ 'in' => @now - 25 })
           Punch.data = @data
         end
@@ -722,21 +760,21 @@ describe Punch do
     end
 
     describe 'when the project does not exist' do
-      before :each do
+      before do
         @project = 'non-existent project'
       end
       
       it 'should return nil' do
-        Punch.list(@project).should be_nil
+        Punch.list(@project).should.be.nil
       end
       
       it 'should return nil if options given' do
-        Punch.list(@project, :after => @now - 500).should be_nil
+        Punch.list(@project, :after => @now - 500).should.be.nil
       end
     end
     
     describe 'when no project is given' do
-      before :each do
+      before do
         @projects = ['test project', 'out project', 'other project']
         @data = {
           @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
@@ -763,13 +801,13 @@ describe Punch do
   end
 
   it 'should get the total time for a project' do
-    Punch.should respond_to(:total)
+    Punch.should.respond_to(:total)
   end
   
   describe 'getting total time for a project' do
-    before :each do
+    before do
       @now = Time.now
-      Time.stubs(:now).returns(@now)
+      Time.stub!(:now).and_return(@now)
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 5000, 'out' => @now - 2500}, {'in' => @now - 2000, 'out' => @now - 1000}, {'in' => @now - 500, 'out' => @now - 100} ] }
       
@@ -782,15 +820,15 @@ describe Punch do
     end
     
     it 'should accept a project name' do
-      lambda { Punch.total('proj') }.should_not raise_error(ArgumentError)
+      lambda { Punch.total('proj') }.should.not.raise(ArgumentError)
     end
     
     it 'should not require a project name' do
-      lambda { Punch.total }.should_not raise_error(ArgumentError)
+      lambda { Punch.total }.should.not.raise(ArgumentError)
     end
     
     it 'should allow options' do
-      lambda { Punch.total('proj', :after => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Punch.total('proj', :after => Time.now) }.should.not.raise(ArgumentError)
     end
     
     describe 'when the project exists' do
@@ -815,7 +853,7 @@ describe Punch do
       end
       
       describe 'and is punched in' do
-        before :each do
+        before do
           @data[@project].push({ 'in' => @now - 25 })
           Punch.data = @data
         end
@@ -839,17 +877,17 @@ describe Punch do
     end
 
     describe 'when the project does not exist' do
-      before :each do
+      before do
         @project = 'non-existent project'
       end
       
       it 'should return nil' do
-        Punch.total(@project).should be_nil
+        Punch.total(@project).should.be.nil
       end
     end
     
     describe 'when no project is given' do
-      before :each do
+      before do
         @projects = ['test project', 'out project', 'other project']
         @data = {
           @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
@@ -874,12 +912,13 @@ describe Punch do
   end
   
   it 'should log information about a project' do
-    Punch.should respond_to(:log)
+    Punch.should.respond_to(:log)
   end
   
   describe 'logging information about a project' do
-    before :each do
+    before do
       @now = Time.now
+      Time.stub!(:now).and_return(@now)
       @project = 'test project'
       @data = { @project => [ {'in' => @now - 50, 'log' => ['some earlier message']} ] }
       
@@ -894,19 +933,27 @@ describe Punch do
     end
     
     it 'should accept a project and message' do
-      lambda { Punch.log('proj', 'some mess') }.should_not raise_error(ArgumentError)
+      lambda { Punch.log('proj', 'some mess') }.should.not.raise(ArgumentError)
     end
     
     it 'should require a message' do
-      lambda { Punch.log('proj') }.should raise_error(ArgumentError)
+      lambda { Punch.log('proj') }.should.raise(ArgumentError)
     end
     
     it 'should require a project' do
-      lambda { Punch.log }.should raise_error(ArgumentError)
+      lambda { Punch.log }.should.raise(ArgumentError)
+    end
+    
+    it 'should accept options' do
+      lambda { Punch.log('proj', 'some mess', :time => Time.now) }.should.not.raise(ArgumentError)
+    end
+    
+    it 'should require a project and message even when options are given' do
+      lambda { Punch.log('proj', :time => Time.now) }.should.raise(ArgumentError)
     end
     
     it 'should check if the project is punched in' do
-      Punch.expects(:in?).with(@project)
+      Punch.should.receive(:in?).with(@project)
       Punch.log(@project, @message)
     end
     
@@ -918,7 +965,33 @@ describe Punch do
       
       it 'should use the given message for the log' do
         Punch.log(@project, @message)
-        Punch.data[@project].last['log'].last.should == @message
+        Punch.data[@project].last['log'].last.should.match(Regexp.new(Regexp.escape(@message)))
+      end
+      
+      it 'should add the formatted time to the message' do
+        time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
+        Punch.log(@project, @message)
+        Punch.data[@project].last['log'].last.should.match(Regexp.new(Regexp.escape(time)))
+      end
+      
+      it 'should format the message as "#{message} @ #{time}"' do
+        time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
+        Punch.log(@project, @message)
+        Punch.data[@project].last['log'].last.should == "#{@message} @ #{time}"
+      end
+      
+      it 'should use a different time if given' do
+        time = @now + 50
+        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
+        Punch.log(@project, @message, :time => time)
+        Punch.data[@project].last['log'].last.should == "#{@message} @ #{time_str}"
+      end
+      
+      it 'should allow the different time to be specified using :at' do
+        time = @now + 50
+        time_str = time.strftime('%Y-%m-%dT%H:%M:%S%z')
+        Punch.log(@project, @message, :at => time)
+        Punch.data[@project].last['log'].last.should == "#{@message} @ #{time_str}"
       end
       
       it 'should return true' do
@@ -926,20 +999,21 @@ describe Punch do
       end
       
       describe 'and has no log' do
-        before :each do
+        before do
           @data = { @project => [ {'in' => @now - 50} ] }
           Punch.data = @data
         end
         
         it 'should create the log' do
+          time = @now.strftime('%Y-%m-%dT%H:%M:%S%z')
           Punch.log(@project, @message)
-          Punch.data[@project].last['log'].should == [@message]
+          Punch.data[@project].last['log'].should == ["#{@message} @ #{time}"]
         end
       end
     end
     
     describe 'when the project is not punched in' do
-      before :each do
+      before do
         @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25, 'log' => ['some earlier message']} ] }
         Punch.data = @data
       end