one_inch_punch 0.0.2 → 0.0.3

data/History.txt

@@ -1,3 +1,18 @@
+== 0.0.3 2008-08-25
+
+* 5 enhancements:
+  * Can now get total time for a project
+  * Listing and getting total time accept arguments of :before and :after
+  * Can log messages while punched in for a project
+  * Punching in and out automatically create log messages
+  * Some operations can be performed on all projects at once:
+    * status
+    * out
+    * list
+    * total
+* 1 change:
+  * Data-changing operations no longer automatically write the data
+
 == 0.0.2 2008-08-22
 
 * 3 tiny enhancements:

data/README.txt

@@ -16,8 +16,8 @@ One-inch punch: Smaller, more effective
 * Can query project status
 * Can delete a project
 * Can list project data
+* Can give total time for a project
 
-* Cannot give a total time (yet)
 * Cannot be used command-line (yet)
 * More, since this is unfinished
 
@@ -32,6 +32,7 @@ One-inch punch: Smaller, more effective
   # do some work
   Punch.out('my project')
   Punch.out?('my project')    # => true
+  Punch.write
 
 == REQUIREMENTS:
 

data/lib/punch/version.rb

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

data/lib/punch.rb

@@ -31,16 +31,14 @@ module Punch
       end
     end
     
-    def status(project)
+    def status(project = nil)
+      return data.keys.inject({}) { |hash, project|  hash.merge(project => status(project)) } unless project
+      
       project_data = data[project]
       return nil if !project_data or project_data.empty?
       
       time_data = project_data.last
-      if time_data['out']
-        'out'
-      else
-        'in'
-      end
+      time_data['out'] ? 'out' : 'in'
     end
     
     def out?(project)
@@ -54,26 +52,73 @@ module Punch
     def in(project)
       return false if in?(project)
       data[project] ||= []
-      data[project].push({'in' => Time.now})
-      write
+      time = Time.now
+      data[project].push({'in' => time})
+      log(project, "punch in @ #{time.strftime('%Y-%m-%dT%H:%M:%S%z')}")
       true
     end
     
-    def out(project)
-      return false if out?(project)
-      data[project].last['out'] = Time.now
-      write
+    def out(project = nil)
+      if project
+        return false unless do_out_single(project)
+      else
+        return false unless data.keys.collect { |project|  do_out_single(project) }.any?
+      end
       true
     end
     
     def delete(project)
       return nil unless data.delete(project)
-      write
       true
     end
     
-    def list(project)
-      data[project]
+    def list(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      project = args.first
+      if project
+        do_list_single(project, options)
+      else
+        data.keys.inject({}) { |hash, project|  hash.merge(project => do_list_single(project, options)) }
+      end
+    end
+    
+    def total(*args)
+      list_data = list(*args)
+      if list_data.is_a?(Hash)
+        list_data.inject({}) { |hash, (project, project_data)|  hash.merge(project => do_total_time(project_data)) }
+      else
+        return nil unless list_data
+        do_total_time(list_data)
+      end
+    end
+    
+    def log(project, message)
+      return false unless in?(project)
+      project_data = data[project].last
+      project_data['log'] ||= []
+      project_data['log'].push message
+      true
+    end
+    
+    
+    private
+    
+    def do_out_single(project)
+      return false if out?(project)
+      time = Time.now
+      log(project, "punch out @ #{time.strftime('%Y-%m-%dT%H:%M:%S%z')}")
+      data[project].last['out'] = time
+    end
+    
+    def do_list_single(project, options)
+      return nil unless project_data = data[project]
+      project_data = project_data.select { |t|  t['in']  > options[:after] }  if options[:after]
+      project_data = project_data.select { |t|  t['out'] < options[:before] } if options[:before]
+      project_data
+    end
+    
+    def do_total_time(list_data)
+      list_data.collect { |t|  ((t['out'] || Time.now) - t['in']).to_i }.inject(0) { |sum, t|  sum + t }
     end
   end
 end

data/spec/punch_spec.rb

@@ -122,7 +122,7 @@ describe Punch do
     end
   end
   
-  it "should give a project's status" do
+  it 'should give project status' do
     Punch.should respond_to(:status)
   end
   
@@ -147,8 +147,8 @@ describe Punch do
       lambda { Punch.status('proj') }.should_not raise_error(ArgumentError)
     end
     
-    it 'should require a project name' do
-      lambda { Punch.status }.should raise_error(ArgumentError)
+    it 'should not require a project name' do
+      lambda { Punch.status }.should_not raise_error(ArgumentError)
     end
     
     it "should return 'out' if the project is currently punched out" do
@@ -178,6 +178,10 @@ describe Punch do
       Punch.status(@projects['out']).should == 'out'
       Punch.status(@projects['in']).should  == 'in'
     end
+    
+    it 'should return the status of all projects if no project name given' do
+      Punch.status.should == { @projects['out'] => 'out', @projects['in'] => 'in' }
+    end
   end
   
   it 'should indicate whether a project is punched out' do
@@ -273,9 +277,6 @@ describe Punch do
         end
       end
       Punch.data = @data
-      
-      @test = states('test').starts_as('setup')
-      Punch.stubs(:write).when(@test.is('setup'))
     end
     
     it 'should accept a project name' do
@@ -286,25 +287,16 @@ describe Punch do
       lambda { Punch.in }.should raise_error(ArgumentError)
     end
     
-    it 'should check whether the project is already punched in' do
-      Punch.expects(:in?).with(@project)
-      Punch.in(@project)
-    end
-    
     describe 'when the project is already punched in' do
       before :each do
-        Punch.stubs(:in?).returns(true)
+        @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25}, {'in' => @now - 5} ] }
+        Punch.data = @data
       end
       
       it 'should not change the project data' do
+        old_data = @data.dup
         Punch.in(@project)
-        Punch.data.should == @data
-      end
-      
-      it 'should not write the data' do
-        @test.become('test')
-        Punch.expects(:write).never.when(@test.is('test'))
-        Punch.in(@project)
+        Punch.data.should == old_data
       end
       
       it 'should return false' do
@@ -313,10 +305,6 @@ describe Punch do
     end
     
     describe 'when the project is not already punched in' do
-      before :each do
-        Punch.stubs(:in?).returns(false)
-      end
-      
       it 'should add a time entry to the project data' do
         Punch.in(@project)
         Punch.data[@project].length.should == 2
@@ -327,9 +315,9 @@ describe Punch do
         Punch.data[@project].last['in'].should == @now
       end
       
-      it 'should write the data' do
-        @test.become('test')
-        Punch.expects(:write).when(@test.is('test'))
+      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.in(@project)
       end
       
@@ -358,14 +346,9 @@ describe Punch do
         Punch.data[@project].last['in'].should == @now
       end
       
-      it 'should use now for the punch-in time' do
-        Punch.in(@project)
-        Punch.data[@project].last['in'].should == @now
-      end
-      
-      it 'should write the data' do
-        @test.become('test')
-        Punch.expects(:write).when(@test.is('test'))
+      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.in(@project)
       end
       
@@ -401,29 +384,15 @@ describe Punch do
       lambda { Punch.out('proj') }.should_not raise_error(ArgumentError)
     end
     
-    it 'should require a project name' do
-      lambda { Punch.out }.should raise_error(ArgumentError)
-    end
-    
-    it 'should check whether the project is already punched out' do
-      Punch.expects(:out?).with(@project)
-      Punch.out(@project)
+    it 'should not require a project name' do
+      lambda { Punch.out }.should_not raise_error(ArgumentError)
     end
     
     describe 'when the project is already punched out' do
-      before :each do
-        Punch.stubs(:out?).returns(true)
-      end
-      
       it 'should not change the project data' do
+        old_data = @data.dup
         Punch.out(@project)
-        Punch.data.should == @data
-      end
-      
-      it 'should not write the data' do
-        @test.become('test')
-        Punch.expects(:write).never.when(@test.is('test'))
-        Punch.out(@project)
+        Punch.data.should == old_data
       end
       
       it 'should return false' do
@@ -433,7 +402,8 @@ describe Punch do
     
     describe 'when the project is not already punched out' do
       before :each do
-        Punch.stubs(:out?).returns(false)
+        @data = { @project => [ {'in' => @now - 50} ] }
+        Punch.data = @data
       end
       
       it 'should not add a time entry to the project data' do
@@ -446,9 +416,9 @@ describe Punch do
         Punch.data[@project].last['out'].should == @now
       end
       
-      it 'should write the data' do
-        @test.become('test')
-        Punch.expects(:write).when(@test.is('test'))
+      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 out @ #{time}")
         Punch.out(@project)
       end
       
@@ -456,6 +426,58 @@ describe Punch do
         Punch.out(@project).should == true
       end
     end
+    
+    describe 'when no project is given' do
+      before :each do
+        @projects = ['test project', 'out project', 'other project']
+        @data = {
+          @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
+          @projects[1] => [ {'in' => @now - 300, 'out' => @now - 250}, {'in' => @now - 40} ],
+          @projects[2] => [ {'in' => @now - 50} ],
+        }
+        Punch.data = @data
+      end
+      
+      it 'should punch out all projects that are currently punched in' do
+        Punch.out
+        Punch.data[@projects[0]].last['out'].should == @now - 25
+        Punch.data[@projects[1]].last['out'].should == @now
+        Punch.data[@projects[2]].last['out'].should == @now
+      end
+      
+      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.out
+      end
+      
+      it 'should return true' do
+        Punch.out.should == true
+      end
+      
+      describe 'when all projects were already punched out' do
+        before :each do
+          @projects = ['test project', 'out project', 'other project']
+          @data = {
+            @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
+            @projects[1] => [ {'in' => @now - 300, 'out' => @now - 250}, {'in' => @now - 40, 'out' => @now - 20} ],
+            @projects[2] => [ {'in' => @now - 50, 'out' => @now - 35} ],
+          }
+          Punch.data = @data
+        end
+        
+        it 'should not change the data' do
+          old_data = @data.dup
+          Punch.out
+          Punch.data.should == old_data
+        end
+        
+        it 'should return false' do
+          Punch.out.should == false
+        end
+      end
+    end
   end
 
   it 'should delete a project' do
@@ -493,12 +515,6 @@ describe Punch do
         Punch.data.should_not include(@project)
       end
       
-      it 'should write the data' do
-        @test.become('test')
-        Punch.expects(:write).when(@test.is('test'))
-        Punch.delete(@project)
-      end
-      
       it 'should return true' do
         Punch.delete(@project).should == true
       end
@@ -509,12 +525,6 @@ describe Punch do
         @project = 'non-existent project'
       end
       
-      it 'should not write the data' do
-        @test.become('test')
-        Punch.expects(:write).never.when(@test.is('test'))
-        Punch.delete(@project)
-      end
-      
       it 'should return nil' do
         Punch.delete(@project).should be_nil
       end
@@ -529,7 +539,7 @@ describe Punch do
     before :each do
       @now = Time.now
       @project = 'test project'
-      @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25} ] }
+      @data = { @project => [ {'in' => @now - 5000, 'out' => @now - 2500}, {'in' => @now - 2000, 'out' => @now - 1000}, {'in' => @now - 500, 'out' => @now - 100} ] }
       
       Punch.instance_eval do
         class << self
@@ -543,14 +553,30 @@ describe Punch do
       lambda { Punch.list('proj') }.should_not raise_error(ArgumentError)
     end
     
-    it 'should require a project name' do
-      lambda { Punch.list }.should raise_error(ArgumentError)
+    it 'should not require a project name' do
+      lambda { Punch.list }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should allow options' do
+      lambda { Punch.list('proj', :after => Time.now) }.should_not raise_error(ArgumentError)
     end
     
     describe 'when the project exists' do
       it 'should return the project data' do
         Punch.list(@project).should == Punch.data[@project]
       end
+      
+      it 'should restrict returned data to times only after a certain time' do
+        Punch.list(@project, :after => @now - 501).should == Punch.data[@project].last(1)
+      end
+      
+      it 'should restrict returned data to times only before a certain time' do
+        Punch.list(@project, :before => @now - 2499).should == Punch.data[@project].first(1)
+      end
+      
+      it 'should restrict returned data to times only within a time range' do
+        Punch.list(@project, :after => @now - 2001, :before => @now - 999).should == Punch.data[@project][1, 1]
+      end
     end
 
     describe 'when the project does not exist' do
@@ -561,6 +587,210 @@ describe Punch do
       it 'should return nil' do
         Punch.list(@project).should be_nil
       end
+      
+      it 'should return nil if options given' do
+        Punch.list(@project, :after => @now - 500).should be_nil
+      end
+    end
+    
+    describe 'when no project is given' do
+      before :each do
+        @projects = ['test project', 'out project', 'other project']
+        @data = {
+          @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
+          @projects[1] => [ {'in' => @now - 300, 'out' => @now - 250}, {'in' => @now - 40, 'out' => @now - 20} ],
+          @projects[2] => [ {'in' => @now - 50, 'out' => @now - 35} ],
+        }
+        Punch.data = @data
+      end
+      
+      it 'should return data for all projects' do
+        Punch.list.should == @data
+      end
+      
+      it 'should respect options' do
+        Punch.list(:after => @now - 51).should == { @projects[0] => @data[@projects[0]], @projects[1] => @data[@projects[1]].last(1), @projects[2] => @data[@projects[2]]}
+      end
+      
+      it 'should not change the stored data when options are given' do
+        old_data = @data.dup
+        Punch.list(:after => @now - 51)
+        Punch.data.should == old_data
+      end
+    end
+  end
+
+  it 'should get the total time for a project' do
+    Punch.should respond_to(:total)
+  end
+  
+  describe 'getting total time for a project' do
+    before :each do
+      @now = Time.now
+      Time.stubs(:now).returns(@now)
+      @project = 'test project'
+      @data = { @project => [ {'in' => @now - 5000, 'out' => @now - 2500}, {'in' => @now - 2000, 'out' => @now - 1000}, {'in' => @now - 500, 'out' => @now - 100} ] }
+      
+      Punch.instance_eval do
+        class << self
+          public :data, :data=
+        end
+      end
+      Punch.data = @data
+    end
+    
+    it 'should accept a project name' do
+      lambda { Punch.total('proj') }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should not require a project name' do
+      lambda { Punch.total }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should allow options' do
+      lambda { Punch.total('proj', :after => Time.now) }.should_not raise_error(ArgumentError)
+    end
+    
+    describe 'when the project exists' do
+      it 'should return the amount of time spent on the project (in seconds)' do
+        Punch.total(@project).should == 3900
+      end
+      
+      it 'should restrict returned amount to times only after a certain time' do
+        Punch.total(@project, :after => @now - 501).should == 400
+      end
+      
+      it 'should restrict returned amount to times only before a certain time' do
+        Punch.total(@project, :before => @now - 2499).should == 2500
+      end
+      
+      it 'should restrict returned amount to times only within a time range' do
+        Punch.total(@project, :after => @now - 2001, :before => @now - 999).should == 1000
+      end
+      
+      describe 'and is punched in' do
+        before :each do
+          @data[@project].push({ 'in' => @now - 25 })
+          Punch.data = @data
+        end
+        
+        it 'give the time spent until now' do
+          Punch.total(@project).should == 3925
+        end
+      end
+    end
+
+    describe 'when the project does not exist' do
+      before :each do
+        @project = 'non-existent project'
+      end
+      
+      it 'should return nil' do
+        Punch.total(@project).should be_nil
+      end
+    end
+    
+    describe 'when no project is given' do
+      before :each do
+        @projects = ['test project', 'out project', 'other project']
+        @data = {
+          @projects[0] => [ {'in' => @now - 50, 'out' => @now - 25} ],
+          @projects[1] => [ {'in' => @now - 300, 'out' => @now - 250}, {'in' => @now - 40, 'out' => @now - 20} ],
+          @projects[2] => [ {'in' => @now - 50, 'out' => @now - 35} ],
+        }
+        Punch.data = @data
+      end
+      
+      it 'should give totals for all projects' do
+        Punch.total.should == { @projects[0] => 25, @projects[1] => 70, @projects[2] => 15}
+      end
+      
+      it 'should respect options' do
+        Punch.total(:after => @now - 51).should == { @projects[0] => 25, @projects[1] => 20, @projects[2] => 15}
+      end
+    end
+  end
+  
+  it 'should log information about a project' do
+    Punch.should respond_to(:log)
+  end
+  
+  describe 'logging information about a project' do
+    before :each do
+      @now = Time.now
+      @project = 'test project'
+      @data = { @project => [ {'in' => @now - 50, 'log' => ['some earlier message']} ] }
+      
+      Punch.instance_eval do
+        class << self
+          public :data, :data=
+        end
+      end
+      Punch.data = @data
+      
+      @message = 'some log message'
+    end
+    
+    it 'should accept a project and message' do
+      lambda { Punch.log('proj', 'some mess') }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a message' do
+      lambda { Punch.log('proj') }.should raise_error(ArgumentError)
+    end
+    
+    it 'should require a project' do
+      lambda { Punch.log }.should raise_error(ArgumentError)
+    end
+    
+    it 'should check if the project is punched in' do
+      Punch.expects(:in?).with(@project)
+      Punch.log(@project, @message)
+    end
+    
+    describe 'when the project is punched in' do
+      it 'should add a log message to the last time entry for the project' do
+        Punch.log(@project, @message)
+        Punch.data[@project].last['log'].length.should == 2
+      end
+      
+      it 'should use the given message for the log' do
+        Punch.log(@project, @message)
+        Punch.data[@project].last['log'].last.should == @message
+      end
+      
+      it 'should return true' do
+        Punch.log(@project, @message).should == true
+      end
+      
+      describe 'and has no log' do
+        before :each do
+          @data = { @project => [ {'in' => @now - 50} ] }
+          Punch.data = @data
+        end
+        
+        it 'should create the log' do
+          Punch.log(@project, @message)
+          Punch.data[@project].last['log'].should == [@message]
+        end
+      end
+    end
+    
+    describe 'when the project is not punched in' do
+      before :each do
+        @data = { @project => [ {'in' => @now - 50, 'out' => @now - 25, 'log' => ['some earlier message']} ] }
+        Punch.data = @data
+      end
+      
+      it 'should not change the project data' do
+        old_data = @data.dup
+        Punch.log(@project, @message)
+        Punch.data.should == old_data
+      end
+      
+      it 'should return false' do
+        Punch.log(@project, @message).should == false
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: one_inch_punch
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Yossef Mendelssohn
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-22 00:00:00 -05:00
+date: 2008-08-25 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency