one_inch_punch 0.2.2 → 0.2.3

data/History.txt

@@ -1,3 +1,10 @@
+== 0.2.3 2008-12-11
+
+* 1 enhancements:
+  * Logging a message now automatically adds a time
+    * A time can be specified for the log message (with now as a default)
+    * punch command takes options for message logging
+
 == 0.2.2 2008-12-01
 
 * 1 enhancement:

data/Manifest.txt

@@ -19,9 +19,7 @@ spec/fixnum_spec.rb
 spec/punch_command_spec.rb
 spec/punch_instance_spec.rb
 spec/punch_spec.rb
-spec/spec.opts
 spec/spec_helper.rb
 tasks/deployment.rake
 tasks/environment.rake
-tasks/rspec.rake
 tasks/website.rake

data/bin/punch

@@ -101,7 +101,7 @@ commands = {
   'log' => lambda do |project|
     if project
       if message = ARGV[2]
-        if Punch.log(project, message)
+        if Punch.log(project, message, OPTIONS)
           Punch.write
         else
           puts "Not punched in to '#{project}'"

data/config/hoe.rb

@@ -11,8 +11,8 @@ EXTRA_DEPENDENCIES = [
 #  ['activesupport', '>= 1.3.1']
 ]    # An array of rubygem dependencies [name, version]
 EXTRA_DEV_DEPENDENCIES = [
-  ['rspec', '>= 1.1.4'],
-  ['mocha', '>= 0.9.1']
+  ['bacon', '>= 1.1.0'],
+  ['facon', '>= 0.4.1']
 ]    # An array of rubygem dependencies [name, version]
 
 @config_file = "~/.rubyforge/user-config.yml"

data/lib/punch/instance.rb

@@ -33,7 +33,7 @@ class Punch
     self.class.total(project, options)
   end
   
-  def log(message)
-    self.class.log(project, message)
+  def log(message, options = {})
+    self.class.log(project, message, options)
   end
 end

data/lib/punch/version.rb

@@ -2,7 +2,7 @@ class Punch
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/punch.rb

@@ -62,8 +62,8 @@ class Punch
       data[project] ||= []
       time = time_from_options(options)
       data[project].push({'in' => time})
-      log(project, "punch in @ #{time.strftime('%Y-%m-%dT%H:%M:%S%z')}")
-      log(project, options[:message]) if options[:message]
+      log(project, 'punch in', :time => time)
+      log(project, options[:message], :time => time) if options[:message]
       true
     end
     
@@ -104,11 +104,13 @@ class Punch
       end
     end
     
-    def log(project, message)
+    def log(project, message, options = {})
+      raise ArgumentError, "Message is not an optional argument" if message.is_a?(Hash)
       return false unless in?(project)
       project_data = data[project].last
       project_data['log'] ||= []
-      project_data['log'].push message
+      time = time_from_options(options)
+      project_data['log'].push "#{message} @ #{time.strftime('%Y-%m-%dT%H:%M:%S%z')}"
       true
     end
     
@@ -118,8 +120,8 @@ class Punch
     def do_out_single(project, options)
       return false if out?(project)
       time = time_from_options(options)
-      log(project, options[:message]) if options[:message]
-      log(project, "punch out @ #{time.strftime('%Y-%m-%dT%H:%M:%S%z')}")
+      log(project, options[:message], :time => time) if options[:message]
+      log(project, 'punch out', :time => time)
       data[project].last['out'] = time
     end
     

data/spec/fixnum_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Fixnum do
   it 'should give an elapsed time' do
-    50.should respond_to(:elapsed_time)
+    50.should.respond_to(:elapsed_time)
   end
   
   describe 'giving an elapsed time' do

data/spec/punch_command_spec.rb

@@ -1,77 +1,78 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
-describe 'punch command' do
-  def run_command(*args)
-    Object.const_set(:ARGV, args)
-    begin
-      eval File.read(File.join(File.dirname(__FILE__), *%w[.. bin punch]))
-    rescue SystemExit
-    end
+def run_command(*args)
+  Object.const_set(:ARGV, args)
+  begin
+    eval File.read(File.join(File.dirname(__FILE__), *%w[.. bin punch]))
+  rescue SystemExit
   end
-  
-  before :each do
+end
+
+
+describe 'punch command' do
+  before do
     [:ARGV, :OPTIONS, :MANDATORY_OPTIONS].each do |const|
       Object.send(:remove_const, const) if Object.const_defined?(const)
     end
     
-    @states = {}
-    %w[puts load write].each do |state|
-      @states[state] = states(state).starts_as('setup')
-    end
-    
-    self.stubs(:puts).when(@states['puts'].is('setup'))
-    Punch.stubs(:load).when(@states['load'].is('setup'))
-    Punch.stubs(:write).when(@states['write'].is('setup'))
+    self.stub!(:puts)
+    Punch.stub!(:load)
+    Punch.stub!(:write)
     
     @project = 'myproj'
   end
   
   it 'should exist' do
-    lambda { run_command }.should_not raise_error(Errno::ENOENT)
+    lambda { run_command }.should.not.raise(Errno::ENOENT)
   end
   
   it 'should require a command' do
-    self.expects(:puts).with(regexp_matches(/usage.+command/i))
+    self.should.receive(:puts) do |output|
+      output.should.match(/usage.+command/i)
+    end
     run_command
   end
   
   describe "when the command is 'total'" do
-    before :each do
-      Punch.stubs(:total)
+    before do
+      Punch.stub!(:total)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('total', @project)
     end
     
     it 'should get the total for the requested project' do
-      Punch.expects(:total).with(@project, anything)
+      Punch.should.receive(:total) do |proj, _|
+        proj.should == @project
+      end
       run_command('total', @project)
     end
     
     it 'should get the total for all projects if none given' do
-      Punch.expects(:total).with(nil, anything)
+      Punch.should.receive(:total) do |proj, _|
+        proj.should.be.nil
+      end
       run_command('total')
     end
     
     it 'should output the total' do
       result = 'total data'
-      Punch.stubs(:total).returns(result)
-      self.expects(:puts).with(result.inspect)
+      Punch.stub!(:total).and_return(result)
+      self.should.receive(:puts).with(result.inspect)
       run_command('total', @project)
     end
     
     it 'should output the total as YAML if no project given' do
       result = 'total data'
-      Punch.stubs(:total).returns(result)
-      self.expects(:puts).with(result.to_yaml)
+      Punch.stub!(:total).and_return(result)
+      self.should.receive(:puts).with(result.to_yaml)
       run_command('total')
     end
     
     it 'should not write the data' do
-      @states['write'].become('test')
-      Punch.expects(:write).never.when(@states['write'].is('test'))
+      Punch.should.receive(:write).never
       run_command('total')
     end
     
@@ -79,300 +80,353 @@ describe 'punch command' do
       it "should pass on an 'after' time option given by --after" do
         time_option = '2008-08-26 09:47'
         time = Time.local(2008, 8, 26, 9, 47)
-        Punch.expects(:total).with(@project, has_entry(:after => time))
+        Punch.should.receive(:total) do |proj, options|
+          proj.should == @project
+          options[:after].should == time
+        end
         run_command('total', @project, '--after', time_option)
       end
       
       it "should pass on a 'before' time option given by --before" do
         time_option = '2008-08-23 15:39'
         time = Time.local(2008, 8, 23, 15, 39)
-        Punch.expects(:total).with(@project, has_entry(:before => time))
+        Punch.should.receive(:total) do |proj, options|
+          proj.should == @project
+          options[:before].should == time
+        end
         run_command('total', @project, '--before', time_option)
       end
       
       it 'should handle a time option given as a date' do
         time_option = '2008-08-23'
         time = Time.local(2008, 8, 23)
-        Punch.expects(:total).with(@project, has_entry(:before => time))
+        Punch.should.receive(:total) do |proj, options|
+          proj.should == @project
+          options[:before].should == time
+        end
         run_command('total', @project, '--before', time_option)
       end
       
       it 'should accept time options if no project given' do
         time_option = '2008-08-26 09:47'
         time = Time.local(2008, 8, 26, 9, 47)
-        Punch.expects(:total).with(nil, has_entry(:before => time))
+        Punch.should.receive(:total) do |proj, options|
+          proj.should.be.nil
+          options[:before].should == time
+        end
         run_command('total', '--before', time_option)
       end
       
       it 'should also pass the formatting option' do
         time_option = '2008-08-26 09:47'
-        Punch.expects(:total).with(@project, has_entry(:format => true))
+        Punch.should.receive(:total) do |proj, options|
+          proj.should == @project
+          options[:format].should == true
+        end
         run_command('total', @project, '--before', time_option)
       end
     end
     
     it 'should pass only the formatting option if no options specified' do
-      Punch.expects(:total).with(@project, {:format => true})
+      Punch.should.receive(:total) do |proj, options|
+        proj.should == @project
+        options[:format].should == true
+      end
       run_command('total', @project)
     end
   end
 
   describe "when the command is 'status'" do
-    before :each do
-      Punch.stubs(:status)
+    before do
+      Punch.stub!(:status)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('status', @project)
     end
     
     it 'should get the status for the requested project' do
-      Punch.expects(:status).with(@project)
+      Punch.should.receive(:status).with(@project)
       run_command('status', @project)
     end
     
     it 'should get the status for all projects if none given' do
-      Punch.expects(:status).with(nil)
+      Punch.should.receive(:status).with(nil)
       run_command('status')
     end
     
     it 'should output the status' do
       result = 'status data'
-      Punch.stubs(:status).returns(result)
-      self.expects(:puts).with(result.inspect)
+      Punch.stub!(:status).and_return(result)
+      self.should.receive(:puts).with(result.inspect)
       run_command('status', @project)
     end
     
     it 'should output the status as YAML if no project given' do
       result = 'status data'
-      Punch.stubs(:status).returns(result)
-      self.expects(:puts).with(result.to_yaml)
+      Punch.stub!(:status).and_return(result)
+      self.should.receive(:puts).with(result.to_yaml)
       run_command('status')
     end
     
     it 'should not write the data' do
-      @states['write'].become('test')
-      Punch.expects(:write).never.when(@states['write'].is('test'))
+      Punch.should.receive(:write).never
       run_command('status')
     end
   end
   
   describe "when the command is 'in'" do
-    before :each do
-      @states['in'] = states('in').starts_as('setup')
-      Punch.stubs(:in).when(@states['write'].is('setup'))
+    before do
+      Punch.stub!(:in)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('in', @project)
     end
     
     it 'should punch in to the given project' do
-      Punch.expects(:in).with(@project, {})
+      Punch.should.receive(:in).with(@project, {})
       run_command('in', @project)
     end
     
     it 'should pass a time if specified on the command line (with --time)' do
       time_option = '2008-08-23 15:39'
       time = Time.local(2008, 8, 23, 15, 39)
-      Punch.expects(:in).with(@project, has_entry(:time => time))
+      Punch.should.receive(:in) do |proj, options|
+        proj.should == @project
+        options[:time].should == time
+      end
       run_command('in', @project, '--time', time_option)
     end
     
     it 'should pass a time if specified on the command line (with --at)' do
       time_option = '2008-08-23 15:39'
       time = Time.local(2008, 8, 23, 15, 39)
-      Punch.expects(:in).with(@project, has_entry(:time => time))
+      Punch.should.receive(:in) do |proj, options|
+        proj.should == @project
+        options[:time].should == time
+      end
       run_command('in', @project, '--at', time_option)
     end
     
     it 'should pass a message if specified on the command line (with --message)' do
       message = 'About to do some amazing work'
-      Punch.expects(:in).with(@project, has_entry(:message => message))
+      Punch.should.receive(:in) do |proj, options|
+        proj.should == @project
+        options[:message].should == message
+      end
       run_command('in', @project, '--message', message)
     end
     
     it 'should pass a message if specified on the command line (with -m)' do
       message = 'About to do some amazing work'
-      Punch.expects(:in).with(@project, has_entry(:message => message))
+      Punch.should.receive(:in) do |proj, options|
+        proj.should == @project
+        options[:message].should == message
+      end
       run_command('in', @project, '-m', message)
     end
     
     describe 'when punched in successfully' do
-      before :each do
-        Punch.stubs(:in).returns(true)
+      before do
+        Punch.stub!(:in).and_return(true)
       end
       
       it 'should write the data' do
-        Punch.expects(:write)
+        Punch.should.receive(:write)
         run_command('in', @project)
       end
       
       it 'should not print anything' do
-        @states['puts'].become('test')
-        self.expects(:puts).never.when(@states['puts'].is('test'))
+        self.should.receive(:puts).never
         run_command('in', @project)
       end
     end
     
     describe 'when not punched in successfully' do
-      before :each do
-        Punch.stubs(:in).returns(false)
+      before do
+        Punch.stub!(:in).and_return(false)
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('in', @project)
       end
       
       it 'should print a message' do
-        self.expects(:puts).with(regexp_matches(/already.+in/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/already.+in/i)
+        end
         run_command('in', @project)
       end
     end
     
     describe 'when no project given' do
       it 'should display an error message' do
-        self.expects(:puts).with(regexp_matches(/project.+require/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/project.+require/i)
+        end
         run_command('in')
       end
       
       it 'should not punch in' do
-        @states['in'].become('test')
-        Punch.stubs(:write)
-        Punch.expects(:in).never.when(@states['in'].is('test'))
+        Punch.stub!(:write)
+        Punch.should.receive(:in).never
         run_command('in')
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('in')
       end
     end
   end
 
   describe "when the command is 'out'" do
-    before :each do
-      Punch.stubs(:out)
+    before do
+      Punch.stub!(:out)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('out', @project)
     end
     
     it 'should punch out of the given project' do
-      Punch.expects(:out).with(@project, {})
+      Punch.should.receive(:out).with(@project, {})
       run_command('out', @project)
     end
     
     it 'should pass a time if specified on the command line (with --time)' do
       time_option = '2008-08-23 15:39'
       time = Time.local(2008, 8, 23, 15, 39)
-      Punch.expects(:out).with(@project, has_entry(:time => time))
+      Punch.should.receive(:out) do |proj, options|
+        proj.should == @project
+        options[:time].should == time
+      end
       run_command('out', @project, '--time', time_option)
     end
     
     it 'should pass a time if specified on the command line (with --at)' do
       time_option = '2008-08-23 15:39'
       time = Time.local(2008, 8, 23, 15, 39)
-      Punch.expects(:out).with(@project, has_entry(:time => time))
+      Punch.should.receive(:out) do |proj, options|
+        proj.should == @project
+        options[:time].should == time
+      end
       run_command('out', @project, '--at', time_option)
     end
     
     it 'should pass a message if specified on the command line (with --message)' do
       message = 'Finished doing some stellar work'
-      Punch.expects(:out).with(@project, has_entry(:message => message))
+      Punch.should.receive(:out) do |proj, options|
+        proj.should == @project
+        options[:message].should == message
+      end
       run_command('out', @project, '--message', message)
     end
     
     it 'should pass a message if specified on the command line (with -m)' do
       message = 'Finished doing some stellar work'
-      Punch.expects(:out).with(@project, has_entry(:message => message))
+      Punch.should.receive(:out) do |proj, options|
+        proj.should == @project
+        options[:message].should == message
+      end
       run_command('out', @project, '-m', message)
     end
     
     describe 'if no project given' do
       it 'should punch out of all projects' do
-        Punch.expects(:out).with(nil, {})
+        Punch.should.receive(:out).with(nil, {})
         run_command('out')
       end
       
       it 'should pass a time if specified on the command line (with --time)' do
         time_option = '2008-08-23 15:39'
         time = Time.local(2008, 8, 23, 15, 39)
-        Punch.expects(:out).with(nil, has_entry(:time => time))
+        Punch.should.receive(:out) do |proj, options|
+          proj.should.be.nil
+          options[:time].should == time
+        end
         run_command('out', '--time', time_option)
       end
       
       it 'should pass a time if specified on the command line (with --at)' do
         time_option = '2008-08-23 15:39'
         time = Time.local(2008, 8, 23, 15, 39)
-        Punch.expects(:out).with(nil, has_entry(:time => time))
+        Punch.should.receive(:out) do |proj, options|
+          proj.should.be.nil
+          options[:time].should == time
+        end
         run_command('out', '--at', time_option)
       end
       
       it 'should pass a message if specified on the command line (with --message)' do
         message = 'Finished doing some stellar work'
-        Punch.expects(:out).with(nil, has_entry(:message => message))
+        Punch.should.receive(:out) do |proj, options|
+          proj.should.be.nil
+          options[:message].should == message
+        end
         run_command('out', '--message', message)
       end
       
       it 'should pass a message if specified on the command line (with -m)' do
         message = 'Finished doing some stellar work'
-        Punch.expects(:out).with(nil, has_entry(:message => message))
+        Punch.should.receive(:out) do |proj, options|
+          proj.should.be.nil
+          options[:message].should == message
+        end
         run_command('out', '-m', message)
       end
     end
     
     describe 'when punched out successfully' do
-      before :each do
-        Punch.stubs(:out).returns(true)
+      before do
+        Punch.stub!(:out).and_return(true)
       end
       
       it 'should write the data' do
-        Punch.expects(:write)
+        Punch.should.receive(:write)
         run_command('out', @project)
       end
       
       it 'should not print anything' do
-        @states['puts'].become('test')
-        self.expects(:puts).never.when(@states['puts'].is('test'))
+        self.should.receive(:puts).never
         run_command('out', @project)
       end
       
       describe 'and no project given' do
         it 'should not print anything' do
-          @states['puts'].become('test')
-          self.expects(:puts).never.when(@states['puts'].is('test'))
+          self.should.receive(:puts).never
           run_command('out')
         end
       end
     end
     
     describe 'when not punched out successfully' do
-      before :each do
-        Punch.stubs(:out).returns(false)
+      before do
+        Punch.stub!(:out).and_return(false)
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('out', @project)
       end
       
       it 'should print a message' do
-        self.expects(:puts).with(regexp_matches(/already.+out/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/already.+out/i)
+        end
         run_command('out', @project)
       end
       
       describe 'and no project given' do
         it 'should print a message' do
-          self.expects(:puts).with(regexp_matches(/already.+out/i))
+          self.should.receive(:puts) do |output|
+            output.should.match(/already.+out/i)
+          end
           run_command('out')
         end
       end
@@ -380,184 +434,207 @@ describe 'punch command' do
   end
   
   describe "when the command is 'delete'" do
-    before :each do
-      @states['delete'] = states('delete').starts_as('setup')
-      Punch.stubs(:delete).when(@states['write'].is('setup'))
+    before do
+      Punch.stub!(:delete)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('delete', @project)
     end
     
     it 'should delete the given project' do
-      Punch.stubs(:write)
-      Punch.expects(:delete).with(@project)
+      Punch.stub!(:write)
+      Punch.should.receive(:delete).with(@project)
       run_command('delete', @project)
     end
     
     it 'should output the result' do
       result = 'result'
-      Punch.stubs(:delete).returns(result)
-      self.expects(:puts).with(result.inspect)
+      Punch.stub!(:delete).and_return(result)
+      self.should.receive(:puts).with(result.inspect)
       run_command('delete', @project)
     end
     
     describe 'when deleted successfully' do
       it 'should write the data' do
-        Punch.stubs(:delete).returns(true)
-        Punch.expects(:write)
+        Punch.stub!(:delete).and_return(true)
+        Punch.should.receive(:write)
         run_command('delete', @project)
       end
     end
     
     describe 'when not deleted successfully' do
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.stubs(:delete).returns(nil)
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.stub!(:delete).and_return(nil)
+        Punch.should.receive(:write).never
         run_command('delete', @project)
       end
     end
     
     describe 'when no project given' do
       it 'should display an error message' do
-        self.expects(:puts).with(regexp_matches(/project.+require/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/project.+require/i)
+        end
         run_command('delete')
       end
       
       it 'should not delete' do
-        @states['delete'].become('test')
-        Punch.stubs(:write)
-        Punch.expects(:delete).never.when(@states['delete'].is('test'))
+        Punch.stub!(:write)
+        Punch.should.receive(:delete).never
         run_command('delete')
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('delete')
       end
     end
   end
   
   describe "when the command is 'log'" do
-    before :each do
-      @states['log'] = states('log').starts_as('setup')
-      Punch.stubs(:log).when(@states['log'].is('setup'))
+    before do
+      Punch.stub!(:log)
       @message = 'log message'
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('log', @project, @message)
     end
     
     it 'should log a message for the given project' do
-      Punch.stubs(:write)
-      Punch.expects(:log).with(@project, @message)
+      Punch.stub!(:write)
+      Punch.should.receive(:log).with(@project, @message, {})
       run_command('log', @project, @message)
     end
     
+    it 'should pass a time if specified on the command line (with --time)' do
+      time_option = '2008-08-23 15:39'
+      time = Time.local(2008, 8, 23, 15, 39)
+      Punch.should.receive(:log) do |proj, msg, options|
+        proj.should == @project
+        msg.should == @message
+        options[:time].should == time
+      end
+      run_command('log', @project, @message, '--time', time_option)
+    end
+    
+    it 'should pass a time if specified on the command line (with --at)' do
+      time_option = '2008-08-23 15:39'
+      time = Time.local(2008, 8, 23, 15, 39)
+      Punch.should.receive(:log) do |proj, msg, options|
+        proj.should == @project
+        msg.should == @message
+        options[:time].should == time
+      end
+      run_command('log', @project, @message, '--at', time_option)
+    end
+    
     describe 'when logged successfully' do
-      before :each do
-        Punch.stubs(:log).returns(true)
+      before do
+        Punch.stub!(:log).and_return(true)
       end
       
       it 'should write the data' do
-        Punch.expects(:write)
+        Punch.should.receive(:write)
         run_command('log', @project, @message)
       end
       
       it 'should not print anything' do
-        @states['puts'].become('test')
-        self.expects(:puts).never.when(@states['write'].is('test'))
+        self.should.receive(:puts).never
         run_command('log', @project, @message)
       end
     end
     
-    describe 'when not deleted successfully' do
-      before :each do
-        Punch.stubs(:log).returns(false)
+    describe 'when not logged successfully' do
+      before do
+        Punch.stub!(:log).and_return(false)
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('log', @project, @message)
       end
       
       it 'should print a message' do
-        self.expects(:puts).with(regexp_matches(/not.+in/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/not.+in/i)
+        end
         run_command('log', @project, @message)
       end
     end
     
     describe 'when no project given' do
       it 'should display an error message' do
-        self.expects(:puts).with(regexp_matches(/project.+require/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/project.+require/i)
+        end
         run_command('log')
       end
       
       it 'should not log' do
-        @states['log'].become('test')
-        Punch.stubs(:write)
-        Punch.expects(:log).never.when(@states['log'].is('test'))
+        Punch.stub!(:write)
+        Punch.should.receive(:log).never
         run_command('log')
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('log')
       end
     end
     
     describe 'when no message given' do
       it 'should display an error message' do
-        self.expects(:puts).with(regexp_matches(/message.+require/i))
+        self.should.receive(:puts) do |output|
+          output.should.match(/message.+require/i)
+        end
         run_command('log', @project)
       end
       
       it 'should not log' do
-        @states['log'].become('test')
-        Punch.stubs(:write)
-        Punch.expects(:log).never.when(@states['log'].is('test'))
+        Punch.stub!(:write)
+        Punch.should.receive(:log).never
         run_command('log', @project)
       end
       
       it 'should not write the data' do
-        @states['write'].become('test')
-        Punch.expects(:write).never.when(@states['write'].is('test'))
+        Punch.should.receive(:write).never
         run_command('log', @project)
       end
     end
   end
   
   describe "when the command is 'list'" do
-    before :each do
-      Punch.stubs(:list)
+    before do
+      Punch.stub!(:list)
     end
     
     it 'should load punch data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       run_command('list', @project)
     end
     
     it 'should get the data for the requested project' do
-      Punch.expects(:list).with(@project, anything)
+      Punch.should.receive(:list) do |proj, _|
+        proj.should == @project
+      end
       run_command('list', @project)
     end
     
     it 'should get the data for all projects if none given' do
-      Punch.expects(:list).with(nil, anything)
+      Punch.should.receive(:list) do |proj, _|
+        proj.should.be.nil
+      end
       run_command('list')
     end
     
     it 'should output the list data' do
       result = 'list data'
-      Punch.stubs(:list).returns(result)
-      self.expects(:puts).with(result.to_yaml)
+      Punch.stub!(:list).and_return(result)
+      self.should.receive(:puts).with(result.to_yaml)
       run_command('list')
     end
     
@@ -565,58 +642,70 @@ describe 'punch command' do
       it "should pass on an 'after' time option given by --after" do
         time_option = '2008-08-26 09:47'
         time = Time.local(2008, 8, 26, 9, 47)
-        Punch.expects(:list).with(@project, has_entry(:after => time))
+        Punch.should.receive(:list) do |proj, options|
+          proj.should == @project
+          options[:after].should == time
+        end
         run_command('list', @project, '--after', time_option)
       end
       
       it "should pass on a 'before' time option given by --before" do
         time_option = '2008-08-23 15:39'
         time = Time.local(2008, 8, 23, 15, 39)
-        Punch.expects(:list).with(@project, has_entry(:before => time))
+        Punch.should.receive(:list) do |proj, options|
+          proj.should == @project
+          options[:before].should == time
+        end
         run_command('list', @project, '--before', time_option)
       end
       
       it 'should handle a time option given as a date' do
         time_option = '2008-08-23'
         time = Time.local(2008, 8, 23)
-        Punch.expects(:list).with(@project, has_entry(:before => time))
+        Punch.should.receive(:list) do |proj, options|
+          proj.should == @project
+          options[:before].should == time
+        end
         run_command('list', @project, '--before', time_option)
       end
       
       it 'should accept time options if no project given' do
         time_option = '2008-08-26 09:47'
         time = Time.local(2008, 8, 26, 9, 47)
-        Punch.expects(:list).with(nil, has_entry(:before => time))
+        Punch.should.receive(:list) do |proj, options|
+          proj.should.be.nil
+          options[:before].should == time
+        end
         run_command('list', '--before', time_option)
       end
     end
     
     it 'should not write the data' do
-      @states['write'].become('test')
-      Punch.expects(:write).never.when(@states['write'].is('test'))
+      Punch.should.receive(:write).never
       run_command('list')
     end
   end
   
   describe 'when the command is unknown' do
     it 'should not error' do
-      lambda { run_command('bunk') }.should_not raise_error
+      lambda { run_command('bunk') }.should.not.raise
     end
     
     it 'should print a message' do
-      self.expects(:puts).with(regexp_matches(/command.+unknown/i))
+      self.should.receive(:puts) do |output|
+        output.should.match(/command.+unknown/i)
+      end
       run_command('bunk')
     end
     
     it 'should not write the data' do
-      @states['write'].become('test')
-      Punch.expects(:write).never.when(@states['write'].is('test'))
+      Punch.should.receive(:write).never
       run_command('bunk')
     end
     
     it 'should not run any punch command' do
-      [:in, :out, :delete, :status, :total, :log].each do |command|
-        Punch.expects(command).never
+      [:in, :out, :delete, :status, :total, :log, :list].each do |command|
+        Punch.should.receive(command).never
       end
       run_command('bunk')
     end