freshtrack 0.4.2 → 0.5.0

data/spec/spec_helper.rb

@@ -1,24 +1,6 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
-end
-
-# this is my favorite way to require ever
-begin
-  require 'mocha'
-rescue LoadError
-  require 'rubygems'
-  gem 'mocha'
-  require 'mocha'
-end
-
-Spec::Runner.configure do |config|
-  config.mock_with :mocha
-end
+require 'rubygems'
+require 'bacon'
+require 'facon'
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-
 require 'freshtrack'

data/spec/time_collectors/one_inch_punch_spec.rb

@@ -2,17 +2,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 require 'freshtrack/time_collectors/one_inch_punch'
 
 describe Freshtrack::TimeCollector::OneInchPunch do
-  before :each do
+  before do
     @collector = Freshtrack::TimeCollector::OneInchPunch.new
   end
   
   describe 'when initialized' do
     it 'should accept options' do
-      lambda { Freshtrack::TimeCollector::OneInchPunch.new(:before => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Freshtrack::TimeCollector::OneInchPunch.new(:before => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { Freshtrack::TimeCollector::OneInchPunch.new }.should_not raise_error(ArgumentError)
+      lambda { Freshtrack::TimeCollector::OneInchPunch.new }.should.not.raise(ArgumentError)
     end
     
     it 'should provide access to the given options' do
@@ -26,117 +26,119 @@ describe Freshtrack::TimeCollector::OneInchPunch do
   end
   
   it 'should get time data' do
-    @collector.should respond_to(:get_time_data)
+    @collector.should.respond_to(:get_time_data)
   end
   
   describe 'getting time data' do
-    before :each do
+    before do
       @project = 'myproj'
-      @time_data = stub('time data')
-      Punch.stubs(:load)
-      Punch.stubs(:list).returns(@time_data)
-      @collector.stubs(:condense_time_data)
+      @time_data = mock('time data')
+      Punch.stub!(:load)
+      Punch.stub!(:list).and_return(@time_data)
+      @collector.stub!(:condense_time_data)
     end
     
     it 'should accept a project' do
-      lambda { @collector.get_time_data(@project) }.should_not raise_error(ArgumentError)
+      lambda { @collector.get_time_data(@project) }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project' do
-      lambda { @collector.get_time_data }.should raise_error(ArgumentError)
+      lambda { @collector.get_time_data }.should.raise(ArgumentError)
     end
     
     it 'should have punch load the time data' do
-      Punch.expects(:load)
+      Punch.should.receive(:load)
       @collector.get_time_data(@project)
     end
     
     it 'should get the time data from punch' do
-      Punch.expects(:list)
+      Punch.should.receive(:list)
       @collector.get_time_data(@project)
     end
     
     it 'should pass the supplied project when getting the time data' do
-      Punch.expects(:list).with(@project, anything)
+      Punch.should.receive(:list) do |project, _|
+        project.should == @project
+      end
       @collector.get_time_data(@project)
     end
     
     it 'should pass the supplied options on when getting the time data' do
       options = { :after => Time.now - 12345 }
-      @collector.stubs(:options).returns(options)
-      Punch.expects(:list).with(@project, options)
+      @collector.stub!(:options).and_return(options)
+      Punch.should.receive(:list).with(@project, options)
       @collector.get_time_data(@project)
     end
     
     it 'should condense the time data' do
-      @collector.expects(:condense_time_data).with(@time_data)
+      @collector.should.receive(:condense_time_data).with(@time_data)
       @collector.get_time_data(@project)
     end
     
     it 'should return the condensed data' do
-      condensed = stub('condensed time data')
-      @collector.stubs(:condense_time_data).returns(condensed)
+      condensed = mock('condensed time data')
+      @collector.stub!(:condense_time_data).and_return(condensed)
       @collector.get_time_data(@project).should == condensed
     end
   end
   
   it 'should condense time data' do
-    @collector.should respond_to(:condense_time_data)
+    @collector.should.respond_to(:condense_time_data)
   end
   
   describe 'condensing time data' do
-    before :each do
-      @time_data = stub('time data')
-      @collector.stubs(:times_to_dates)
-      @collector.stubs(:group_date_data)
+    before do
+      @time_data = mock('time data')
+      @collector.stub!(:times_to_dates)
+      @collector.stub!(:group_date_data)
     end
     
     it 'should accept time data' do
-      lambda { @collector.condense_time_data(@time_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.condense_time_data(@time_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require time data' do
-      lambda { @collector.condense_time_data }.should raise_error(ArgumentError)
+      lambda { @collector.condense_time_data }.should.raise(ArgumentError)
     end
     
     it 'should convert times to dates and hour differences' do
-      @collector.expects(:times_to_dates).with(@time_data)
+      @collector.should.receive(:times_to_dates).with(@time_data)
       @collector.condense_time_data(@time_data)
     end
     
     it 'should group date and hour differences' do
-      date_hour_data = stub('date/hour data')
-      @collector.stubs(:times_to_dates).returns(date_hour_data)
-      @collector.expects(:group_date_data).with(date_hour_data)
+      date_hour_data = mock('date/hour data')
+      @collector.stub!(:times_to_dates).and_return(date_hour_data)
+      @collector.should.receive(:group_date_data).with(date_hour_data)
       @collector.condense_time_data(@time_data)
     end
     
     it 'should return the grouped date/hour data' do
-      grouped_dates = stub('grouped date/hour data')
-      @collector.stubs(:group_date_data).returns(grouped_dates)
+      grouped_dates = mock('grouped date/hour data')
+      @collector.stub!(:group_date_data).and_return(grouped_dates)
       @collector.condense_time_data(@time_data).should == grouped_dates
     end
   end
   
   it 'should convert times to dates and hour differences' do
-    @collector.should respond_to(:times_to_dates)
+    @collector.should.respond_to(:times_to_dates)
   end
   
   describe 'converting times to dates and hour differences' do
-    before :each do
+    before do
       @time_data = []
     end
     
     it 'should accept time data' do
-      lambda { @collector.times_to_dates(@time_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.times_to_dates(@time_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require time data' do
-      lambda { @collector.times_to_dates }.should raise_error(ArgumentError)
+      lambda { @collector.times_to_dates }.should.raise(ArgumentError)
     end
     
     it 'should return an array' do
-      @collector.times_to_dates(@time_data).should be_kind_of(Array)
+      @collector.times_to_dates(@time_data).should.be.kind_of(Array)
     end
     
     it 'should replace the in/out time data with a single date' do
@@ -144,9 +146,9 @@ describe Freshtrack::TimeCollector::OneInchPunch do
       result = @collector.times_to_dates(@time_data)
       result = result.first
       
-      result.should     have_key('date')
-      result.should_not have_key('in')
-      result.should_not have_key('out')
+      result.should.has_key('date')
+      result.should.not.has_key('in')
+      result.should.not.has_key('out')
     end
     
     it 'should make the date appopriate to the time' do
@@ -167,7 +169,7 @@ describe Freshtrack::TimeCollector::OneInchPunch do
       @time_data.push({ 'in' => Time.local(2008, 1, 25, 6,  25, 0), 'out' => Time.local(2008, 1, 25, 7,  25, 0) })
       result = @collector.times_to_dates(@time_data)
       result = result.first
-      result.should have_key('hours')
+      result.should.has_key('hours')
     end
     
     it 'should make the hour data appropriate to the in/out difference' do
@@ -179,24 +181,24 @@ describe Freshtrack::TimeCollector::OneInchPunch do
   end
   
   it 'should group date data' do
-    @collector.should respond_to(:group_date_data)
+    @collector.should.respond_to(:group_date_data)
   end
   
   describe 'grouping date data' do
-    before :each do
+    before do
       @date_data = []
     end
     
     it 'should accept date data' do
-      lambda { @collector.group_date_data(@date_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.group_date_data(@date_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require date data' do
-      lambda { @collector.group_date_data }.should raise_error(ArgumentError)
+      lambda { @collector.group_date_data }.should.raise(ArgumentError)
     end
     
     it 'should return an array' do
-      @collector.group_date_data(@date_data).should be_kind_of(Array)
+      @collector.group_date_data(@date_data).should.be.kind_of(Array)
     end
     
     it 'should group the data by date' do
@@ -223,10 +225,10 @@ describe Freshtrack::TimeCollector::OneInchPunch do
       @date_data.push({ 'date' => today + 1, 'hours' => 2, 'log' => [] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['hours'].should == 4
       
-      result[1]['date'].should  == today + 1
+      result[1]['date'].should == today + 1
       result[1]['hours'].should == 2
     end
     
@@ -235,7 +237,7 @@ describe Freshtrack::TimeCollector::OneInchPunch do
       @date_data.push({ 'date' => today, 'hours' => 1.666666666, 'log' => [] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['hours'].should == 1.67
     end
     
@@ -246,13 +248,13 @@ describe Freshtrack::TimeCollector::OneInchPunch do
       @date_data.push({ 'date' => today + 1, 'hours' => 0, 'log' => ['punch in 3', 'punch out 3'] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['notes'].should == "punch in 1\npunch out 1\n--------------------\npunch in 2\npunch out 2"
-      result[0].should_not have_key('log')
+      result[0].should.not.has_key('log')
       
-      result[1]['date'].should  == today + 1
+      result[1]['date'].should == today + 1
       result[1]['notes'].should == "punch in 3\npunch out 3"
-      result[1].should_not have_key('log')
+      result[1].should.not.has_key('log')
     end
   end
 end

data/spec/time_collectors/punch_spec.rb

@@ -2,17 +2,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 require 'freshtrack/time_collectors/punch'
 
 describe Freshtrack::TimeCollector::Punch do
-  before :each do
+  before do
     @collector = Freshtrack::TimeCollector::Punch.new
   end
   
   describe 'when initialized' do
     it 'should accept options' do
-      lambda { Freshtrack::TimeCollector::Punch.new(:before => Time.now) }.should_not raise_error(ArgumentError)
+      lambda { Freshtrack::TimeCollector::Punch.new(:before => Time.now) }.should.not.raise(ArgumentError)
     end
     
     it 'should not require options' do
-      lambda { Freshtrack::TimeCollector::Punch.new }.should_not raise_error(ArgumentError)
+      lambda { Freshtrack::TimeCollector::Punch.new }.should.not.raise(ArgumentError)
     end
     
     it 'should provide access to the given options' do
@@ -26,33 +26,37 @@ describe Freshtrack::TimeCollector::Punch do
   end
   
   it 'should get time data' do
-    @collector.should respond_to(:get_time_data)
+    @collector.should.respond_to(:get_time_data)
   end
   
   describe 'getting time data' do
-    before :each do
+    before do
       @project = 'myproj'
-      @time_data = stub('time data')
-      IO.stubs(:read).returns(@time_data)
-      @collector.stubs(:convert_time_data)
-      @collector.stubs(:condense_time_data)
+      @time_data = mock('time data')
+      IO.stub!(:read).and_return(@time_data)
+      @collector.stub!(:convert_time_data)
+      @collector.stub!(:condense_time_data)
     end
     
     it 'should accept a project' do
-      lambda { @collector.get_time_data(@project) }.should_not raise_error(ArgumentError)
+      lambda { @collector.get_time_data(@project) }.should.not.raise(ArgumentError)
     end
     
     it 'should require a project' do
-      lambda { @collector.get_time_data }.should raise_error(ArgumentError)
+      lambda { @collector.get_time_data }.should.raise(ArgumentError)
     end
     
     it 'should get the time data (from punch)' do
-      IO.expects(:read).with(regexp_matches(/^\| punch list\b/))
+      IO.should.receive(:read) do |arg|
+        arg.should.match(/^\| punch list\b/)
+      end
       @collector.get_time_data(@project)
     end
     
     it 'should pass the supplied project when getting the time data' do
-      IO.expects(:read).with(regexp_matches(/\b#{@project}\b/))
+      IO.should.receive(:read) do |arg|
+        arg.should.match(/\b#{@project}\b/)
+      end
       @collector.get_time_data(@project)
     end
     
@@ -60,123 +64,127 @@ describe Freshtrack::TimeCollector::Punch do
       time = Time.local(2007, 3, 4, 13, 47, 56)
       options = { :after => time }
       option_str = '--after 2007-03-04T13:47:56-0500'
-      @collector.stubs(:options).returns(options)
-      IO.expects(:read).with(regexp_matches(/\b#{@project} #{option_str}\b/))
+      @collector.stub!(:options).and_return(options)
+      IO.should.receive(:read) do |arg|
+        arg.should.match(/\b#{@project} #{option_str}\b/)
+      end
       @collector.get_time_data(@project)
     end
     
     it 'should default option string to empty string' do
-      IO.expects(:read).with(regexp_matches(/\b#{@project} $/))
+      IO.should.receive(:read) do |arg|
+        arg.should.match(/\b#{@project} $/)
+      end
       @collector.get_time_data(@project)
     end
     
     it 'should convert the time data' do
-      @collector.expects(:convert_time_data).with(@time_data)
+      @collector.should.receive(:convert_time_data).with(@time_data)
       @collector.get_time_data(@project)
     end
     
     it 'should condense the converted time data' do
-      converted_time_data = stub('converted time data')
-      @collector.stubs(:convert_time_data).returns(converted_time_data)
-      @collector.expects(:condense_time_data).with(converted_time_data)
+      converted_time_data = mock('converted time data')
+      @collector.stub!(:convert_time_data).and_return(converted_time_data)
+      @collector.should.receive(:condense_time_data).with(converted_time_data)
       @collector.get_time_data(@project)
     end
     
     it 'should return the condensed data' do
-      condensed = stub('condensed time data')
-      @collector.stubs(:condense_time_data).returns(condensed)
+      condensed = mock('condensed time data')
+      @collector.stub!(:condense_time_data).and_return(condensed)
       @collector.get_time_data(@project).should == condensed
     end
   end
   
   it 'should convert time data' do
-    @collector.should respond_to(:convert_time_data)
+    @collector.should.respond_to(:convert_time_data)
   end
   
   describe 'converting time data' do
-    before :each do
-      @time_data = stub('time data')
-      YAML.stubs(:load)
-      @collector.stubs(:condense_time_data)
+    before do
+      @time_data = mock('time data')
+      YAML.stub!(:load)
+      @collector.stub!(:condense_time_data)
     end
     
     it 'should accept time data' do
-      lambda { @collector.convert_time_data(@time_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.convert_time_data(@time_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require time data' do
-      lambda { @collector.convert_time_data }.should raise_error(ArgumentError)
+      lambda { @collector.convert_time_data }.should.raise(ArgumentError)
     end
 
     it 'should convert the time data from YAML' do
-      YAML.expects(:load).with(@time_data)
+      YAML.should.receive(:load).with(@time_data)
       @collector.convert_time_data(@time_data)
     end
     
     it 'should return the converted time data' do
-      converted = stub('converted time data')
-      YAML.stubs(:load).returns(converted)
+      converted = mock('converted time data')
+      YAML.stub!(:load).and_return(converted)
       @collector.convert_time_data(@time_data).should == converted
     end
   end
   
   it 'should condense time data' do
-    @collector.should respond_to(:condense_time_data)
+    @collector.should.respond_to(:condense_time_data)
   end
   
   describe 'condensing time data' do
-    before :each do
-      @time_data = stub('time data')
-      @collector.stubs(:times_to_dates)
-      @collector.stubs(:group_date_data)
+    before do
+      @time_data = mock('time data')
+      @collector.stub!(:times_to_dates)
+      @collector.stub!(:group_date_data)
     end
     
     it 'should accept time data' do
-      lambda { @collector.condense_time_data(@time_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.condense_time_data(@time_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require time data' do
-      lambda { @collector.condense_time_data }.should raise_error(ArgumentError)
+      lambda { @collector.condense_time_data }.should.raise(ArgumentError)
     end
     
     it 'should convert times to dates and hour differences' do
-      @collector.expects(:times_to_dates).with(@time_data)
+      @collector.should.receive(:times_to_dates).with(@time_data)
       @collector.condense_time_data(@time_data)
     end
     
     it 'should group date and hour differences' do
-      date_hour_data = stub('date/hour data')
-      @collector.stubs(:times_to_dates).returns(date_hour_data)
-      @collector.expects(:group_date_data).with(date_hour_data)
+      date_hour_data = mock('date/hour data')
+      @collector.stub!(:times_to_dates).and_return(date_hour_data)
+      @collector.should.receive(:group_date_data).with(date_hour_data)
       @collector.condense_time_data(@time_data)
     end
     
     it 'should return the grouped date/hour data' do
-      grouped_dates = stub('grouped date/hour data')
-      @collector.stubs(:group_date_data).returns(grouped_dates)
+      grouped_dates = mock('grouped date/hour data')
+      @collector.stub!(:group_date_data).and_return(grouped_dates)
       @collector.condense_time_data(@time_data).should == grouped_dates
     end
   end
   
   it 'should convert times to dates and hour differences' do
-    @collector.should respond_to(:times_to_dates)
+    @collector.should.respond_to(:times_to_dates)
   end
   
   describe 'converting times to dates and hour differences' do
-    before :each do
+    before do
       @time_data = []
     end
     
     it 'should accept time data' do
-      lambda { @collector.times_to_dates(@time_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.times_to_dates(@time_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require time data' do
-      lambda { @collector.times_to_dates }.should raise_error(ArgumentError)
+      lambda { @collector.times_to_dates }.should.raise(ArgumentError)
     end
     
     it 'should return an array' do
-      @collector.times_to_dates(@time_data).should be_kind_of(Array)
+      @collector.times_to_dates(@time_data).should.be.kind_of(Array)
     end
     
     it 'should replace the in/out time data with a single date' do
@@ -184,9 +192,9 @@ describe Freshtrack::TimeCollector::Punch do
       result = @collector.times_to_dates(@time_data)
       result = result.first
       
-      result.should     have_key('date')
-      result.should_not have_key('in')
-      result.should_not have_key('out')
+      result.should.has_key('date')
+      result.should.not.has_key('in')
+      result.should.not.has_key('out')
     end
     
     it 'should make the date appopriate to the time' do
@@ -207,7 +215,7 @@ describe Freshtrack::TimeCollector::Punch do
       @time_data.push({ 'in' => Time.local(2008, 1, 25, 6,  25, 0), 'out' => Time.local(2008, 1, 25, 7,  25, 0) })
       result = @collector.times_to_dates(@time_data)
       result = result.first
-      result.should have_key('hours')
+      result.should.has_key('hours')
     end
     
     it 'should make the hour data appropriate to the in/out difference' do
@@ -219,24 +227,24 @@ describe Freshtrack::TimeCollector::Punch do
   end
   
   it 'should group date data' do
-    @collector.should respond_to(:group_date_data)
+    @collector.should.respond_to(:group_date_data)
   end
   
   describe 'grouping date data' do
-    before :each do
+    before do
       @date_data = []
     end
     
     it 'should accept date data' do
-      lambda { @collector.group_date_data(@date_data) }.should_not raise_error(ArgumentError)
+      lambda { @collector.group_date_data(@date_data) }.should.not.raise(ArgumentError)
     end
     
     it 'should require date data' do
-      lambda { @collector.group_date_data }.should raise_error(ArgumentError)
+      lambda { @collector.group_date_data }.should.raise(ArgumentError)
     end
     
     it 'should return an array' do
-      @collector.group_date_data(@date_data).should be_kind_of(Array)
+      @collector.group_date_data(@date_data).should.be.kind_of(Array)
     end
     
     it 'should group the data by date' do
@@ -263,10 +271,10 @@ describe Freshtrack::TimeCollector::Punch do
       @date_data.push({ 'date' => today + 1, 'hours' => 2, 'log' => [] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['hours'].should == 4
       
-      result[1]['date'].should  == today + 1
+      result[1]['date'].should == today + 1
       result[1]['hours'].should == 2
     end
     
@@ -275,7 +283,7 @@ describe Freshtrack::TimeCollector::Punch do
       @date_data.push({ 'date' => today, 'hours' => 1.666666666, 'log' => [] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['hours'].should == 1.67
     end
     
@@ -286,13 +294,13 @@ describe Freshtrack::TimeCollector::Punch do
       @date_data.push({ 'date' => today + 1, 'hours' => 0, 'log' => ['punch in 3', 'punch out 3'] })
       result = @collector.group_date_data(@date_data)
       
-      result[0]['date'].should  == today
+      result[0]['date'].should == today
       result[0]['notes'].should == "punch in 1\npunch out 1\n--------------------\npunch in 2\npunch out 2"
-      result[0].should_not have_key('log')
+      result[0].should.not.has_key('log')
       
-      result[1]['date'].should  == today + 1
+      result[1]['date'].should == today + 1
       result[1]['notes'].should == "punch in 3\npunch out 3"
-      result[1].should_not have_key('log')
+      result[1].should.not.has_key('log')
     end
   end
 end