timetrap 1.5.3 → 1.6.0

data/lib/timetrap/config.rb

@@ -24,8 +24,8 @@ module Timetrap
       overrides = File.exist?(PATH) ? YAML.load(File.read(PATH)) : {}
       defaults.merge(overrides)[key]
     rescue => e
-      puts "invalid config file"
-      puts e.message
+      warn "invalid config file"
+      warn e.message
       defaults[key]
     end
 

data/lib/timetrap/helpers.rb

@@ -7,7 +7,7 @@ module Timetrap
       elsif sheet =~ /.+/
         Timetrap::Entry.filter('sheet = ?', sheet)
       else
-        Timetrap::Entry.filter('sheet = ?', Timetrap.current_sheet)
+        Timetrap::Entry.filter('sheet = ?', Timer.current_sheet)
       end
       ee = ee.filter('start >= ?', Date.parse(args['-s'])) if args['-s']
       ee = ee.filter('start <= ?', Date.parse(args['-e']) + 1) if args['-e']
@@ -49,11 +49,19 @@ module Timetrap
     end
 
     def sheet_name_from_string string
-      return "all" if string =~ /^\W*all\W*$/
-      return "" unless string =~ /.+/
-      DB[:entries].filter(:sheet.like("#{string}%")).first[:sheet]
-    rescue
-      ""
+      string = string.strip
+      case string
+      when /^\W*all\W*$/ then "all"
+      when /^$/ then Timer.current_sheet
+      else
+        entry = DB[:entries].filter(:sheet.like("#{string}")).first ||
+          DB[:entries].filter(:sheet.like("#{string}%")).first
+        if entry
+          entry[:sheet]
+        else
+          raise "Can't find sheet matching #{string.inspect}"
+        end
+      end
     end
   end
 end

data/lib/timetrap/timer.rb

@@ -0,0 +1,55 @@
+module Timetrap
+  module Timer
+    class AlreadyRunning < StandardError
+      def message
+        "Timetrap is already running"
+      end
+    end
+
+    extend self
+
+    def current_sheet= sheet
+      m = Meta.find_or_create(:key => 'current_sheet')
+      m.value = sheet
+      m.save
+    end
+
+    def current_sheet
+      unless Meta.find(:key => 'current_sheet')
+        Meta.create(:key => 'current_sheet', :value => 'default')
+      end
+      Meta.find(:key => 'current_sheet').value
+    end
+
+    def entries sheet = nil
+      Entry.filter(:sheet => sheet).order_by(:start)
+    end
+
+    def running?
+      !!active_entry
+    end
+
+    def active_entry(sheet=nil)
+      Entry.find(:sheet => (sheet || Timer.current_sheet), :end => nil)
+    end
+
+    def running_entries
+      Entry.filter(:end => nil)
+    end
+
+    def stop sheet, time = nil
+      if a = active_entry(sheet)
+        time ||= Time.now
+        a.end = time
+        a.save
+      end
+    end
+
+    def start note, time = nil
+      raise AlreadyRunning if running?
+      time ||= Time.now
+      Entry.create(:sheet => Timer.current_sheet, :note => note, :start => time).save
+    end
+
+  end
+end

data/spec/spec.opts

@@ -1 +1,2 @@
 --color
+--format profile

data/spec/timetrap_spec.rb

@@ -1,5 +1,5 @@
 TEST_MODE = true
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timetrap')
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'timetrap'))
 require 'spec'
 require 'fakefs/safe'
 
@@ -27,6 +27,7 @@ describe Timetrap do
     Timetrap::Meta.create_table!
     $stdout = StringIO.new
     $stdin = StringIO.new
+    $stderr = StringIO.new
   end
 
   describe 'CLI' do
@@ -36,6 +37,13 @@ describe Timetrap do
         Timetrap::CLI.invoke
       end
 
+      describe 'with no command' do
+        it "should invoke --help" do
+          invoke ''
+          $stdout.string.should include "Usage"
+        end
+      end
+
       describe 'archive' do
         before do
           3.times do |i|
@@ -80,64 +88,64 @@ describe Timetrap do
 
       describe 'edit' do
         before do
-          Timetrap.start "running entry", nil
+          Timetrap::Timer.start "running entry", nil
         end
 
         it "should edit the description of the active period" do
-          Timetrap.active_entry.note.should == 'running entry'
+          Timetrap::Timer.active_entry.note.should == 'running entry'
           invoke 'edit new description'
-          Timetrap.active_entry.note.should == 'new description'
+          Timetrap::Timer.active_entry.note.should == 'new description'
         end
 
         it "should allow you to move an entry to another sheet" do
           invoke 'edit --move blahblah'
-          Timetrap.active_entry[:sheet].should == 'blahblah'
+          Timetrap::Timer.active_entry[:sheet].should == 'blahblah'
           invoke 'edit -m blahblahblah'
-          Timetrap.active_entry[:sheet].should == 'blahblahblah'
+          Timetrap::Timer.active_entry[:sheet].should == 'blahblahblah'
         end
 
         it "should change the current sheet if the current entry's sheet is changed" do
-          Timetrap.current_sheet.should_not == 'blahblahblah'
+          Timetrap::Timer.current_sheet.should_not == 'blahblahblah'
           invoke 'edit -m blahblahblah'
-          Timetrap.active_entry[:sheet].should == 'blahblahblah'
-          Timetrap.current_sheet.should == 'blahblahblah'
+          Timetrap::Timer.active_entry[:sheet].should == 'blahblahblah'
+          Timetrap::Timer.current_sheet.should == 'blahblahblah'
         end
 
         it "should change the current sheet if a non current entry's sheet is changed" do
-          sheet = Timetrap.current_sheet
-          id = Timetrap.active_entry[:id]
+          sheet = Timetrap::Timer.current_sheet
+          id = Timetrap::Timer.active_entry[:id]
           invoke 'out'
           invoke "edit -m blahblahblah -i #{id}"
-          Timetrap.current_sheet.should == sheet
+          Timetrap::Timer.current_sheet.should == sheet
           Timetrap::Entry[id][:sheet].should == 'blahblahblah'
         end
 
         it "should allow appending to the description of the active period" do
           with_stubbed_config('append_notes_delimiter' => '//')
-          Timetrap.active_entry.note.should == 'running entry'
+          Timetrap::Timer.active_entry.note.should == 'running entry'
           invoke 'edit --append new'
-          Timetrap.active_entry.note.should == 'running entry//new'
+          Timetrap::Timer.active_entry.note.should == 'running entry//new'
           invoke 'edit -z more'
-          Timetrap.active_entry.note.should == 'running entry//new//more'
+          Timetrap::Timer.active_entry.note.should == 'running entry//new//more'
         end
 
         it "should edit the start time of the active period" do
           invoke 'edit --start "yesterday 10am"'
-          Timetrap.active_entry.start.should == Chronic.parse("yesterday 10am")
-          Timetrap.active_entry.note.should == 'running entry'
+          Timetrap::Timer.active_entry.start.should == Chronic.parse("yesterday 10am")
+          Timetrap::Timer.active_entry.note.should == 'running entry'
         end
 
         it "should edit the end time of the active period" do
-          entry = Timetrap.active_entry
+          entry = Timetrap::Timer.active_entry
           invoke 'edit --end "yesterday 10am"'
           entry.refresh.end.should == Chronic.parse("yesterday 10am")
           entry.refresh.note.should == 'running entry'
         end
 
         it "should edit a non running entry based on id" do
-          not_running = Timetrap.active_entry
-          Timetrap.stop
-          Timetrap.start "another entry", nil
+          not_running = Timetrap::Timer.active_entry
+          Timetrap::Timer.stop(Timetrap::Timer.current_sheet)
+          Timetrap::Timer.start "another entry", nil
           invoke "edit --id #{not_running.id} a new description"
           not_running.refresh.note.should == 'a new description'
         end
@@ -219,30 +227,39 @@ Grand Total                                 10:00:00
         end
 
         it "should display the current timesheet" do
-          Timetrap.current_sheet = 'SpecSheet'
+          Timetrap::Timer.current_sheet = 'SpecSheet'
           invoke 'display'
           $stdout.string.should == @desired_output
         end
 
         it "should display a non current timesheet" do
-          Timetrap.current_sheet = 'another'
+          Timetrap::Timer.current_sheet = 'another'
           invoke 'display SpecSheet'
           $stdout.string.should == @desired_output
         end
 
         it "should display a non current timesheet based on a partial name match" do
-          Timetrap.current_sheet = 'another'
+          Timetrap::Timer.current_sheet = 'another'
           invoke 'display S'
           $stdout.string.should == @desired_output
         end
 
+        it "should prefer an exact match of a named sheet to a partial match" do
+          Timetrap::Timer.current_sheet = 'Spec'
+          Timetrap::Entry.create( :sheet => 'Spec',
+            :note => 'entry 5', :start => '2008-10-05 18:00:00'
+          )
+          invoke 'display Spec'
+          $stdout.string.should include("entry 5")
+        end
+
         it "should display a timesheet with ids" do
           invoke 'display S --ids'
           $stdout.string.should == @desired_output_with_ids
         end
 
         it "should display all timesheets" do
-          Timetrap.current_sheet = 'another'
+          Timetrap::Timer.current_sheet = 'another'
           invoke 'display all'
           $stdout.string.should == @desired_output_for_all
         end
@@ -352,7 +369,7 @@ END:VCALENDAR
         end
 
         it "should not start the time if the timetrap is running" do
-          Timetrap.stub!(:running?).and_return true
+          Timetrap::Timer.stub!(:running?).and_return true
           lambda do
             invoke 'in'
           end.should_not change(Timetrap::Entry, :count)
@@ -368,7 +385,7 @@ END:VCALENDAR
           Time.stub!(:now).and_return now
           invoke 'in work --at="18 minutes ago"'
           Timetrap::Entry.order_by(:id).last.should be_nil
-          $stdout.string.should =~ /\w+/
+          $stderr.string.should =~ /\w+/
         end
 
         it "should fail with a time argurment of total garbage" do
@@ -376,7 +393,7 @@ END:VCALENDAR
           Time.stub!(:now).and_return now
           invoke 'in work --at "total garbage"'
           Timetrap::Entry.order_by(:id).last.should be_nil
-          $stdout.string.should =~ /\w+/
+          $stderr.string.should =~ /\w+/
         end
       end
 
@@ -418,9 +435,9 @@ END:VCALENDAR
 
       describe "list" do
         describe "with no sheets defined" do
-          it "should say that there are no sheets" do
+          it "should list the default sheet" do
             invoke 'list'
-            $stdout.string.chomp.should == 'No sheets found'
+            $stdout.string.chomp.should == " Timesheet  Running     Today       Total Time\n*default     0:00:00     0:00:00     0:00:00"
           end
         end
 
@@ -437,13 +454,25 @@ END:VCALENDAR
                          :end => nil)
             create_entry( :sheet => 'Sheet 1', :start => '2008-10-03 16:00:00',
                          :end => '2008-10-03 18:00:00')
-            Timetrap.current_sheet = 'A Longly Named Sheet 2'
+            Timetrap::Timer.current_sheet = 'A Longly Named Sheet 2'
           end
           it "should list available timesheets" do
             invoke 'list'
             $stdout.string.should == <<-OUTPUT
  Timesheet                 Running     Today       Total Time
 *A Longly Named Sheet 2     4:00:00     6:00:00    10:00:00
+ Sheet 1                    0:00:00     0:00:00     2:00:00
+            OUTPUT
+          end
+
+          it "should include the active timesheet even if it has no entries" do
+            invoke 'sheet empty sheet'
+            $stdout.string = ''
+            invoke 'list'
+            $stdout.string.should == <<-OUTPUT
+ Timesheet                 Running     Today       Total Time
+ A Longly Named Sheet 2     4:00:00     6:00:00    10:00:00
+*empty sheet                0:00:00     0:00:00     0:00:00
  Sheet 1                    0:00:00     0:00:00     2:00:00
             OUTPUT
           end
@@ -452,14 +481,14 @@ END:VCALENDAR
 
       describe "now" do
         before do
-          Timetrap.current_sheet = 'current sheet'
+          Timetrap::Timer.current_sheet = 'current sheet'
         end
 
         describe "when the current timesheet isn't running" do
           it "should show that it isn't running" do
             invoke 'now'
             $stdout.string.should == <<-OUTPUT
-current sheet: not running
+*current sheet: not running
             OUTPUT
           end
         end
@@ -467,25 +496,44 @@ current sheet: not running
         describe "when the current timesheet is running" do
           before do
             invoke 'in a timesheet that is running'
-            @entry = Timetrap.active_entry
-            @entry.stub!(:start).and_return(Time.at(0))
+            @entry = Timetrap::Timer.active_entry
+            @entry.start = Time.at(0)
+            @entry.save
             Time.stub!(:now).and_return Time.at(60)
-            Timetrap.stub!(:active_entry).and_return @entry
           end
 
           it "should show how long the current item is running for" do
             invoke 'now'
             $stdout.string.should == <<-OUTPUT
-current sheet: 0:01:00 (a timesheet that is running)
+*current sheet: 0:01:00 (a timesheet that is running)
             OUTPUT
           end
+
+          describe "and another timesheet is running too" do
+            before do
+              invoke 'sheet another-sheet'
+              invoke 'in also running'
+              @entry = Timetrap::Timer.active_entry
+              @entry.start = Time.at(0)
+              @entry.save
+              Time.stub!(:now).and_return Time.at(60)
+            end
+
+            it "should show both entries" do
+            invoke 'now'
+            $stdout.string.should == <<-OUTPUT
+ current sheet: 0:01:00 (a timesheet that is running)
+*another-sheet: 0:01:00 (also running)
+            OUTPUT
+            end
+          end
         end
       end
 
       describe "out" do
         before :each do
           invoke 'in'
-          @active = Timetrap.active_entry
+          @active = Timetrap::Timer.active_entry
           @now = Time.now
           Time.stub!(:now).and_return @now
         end
@@ -504,36 +552,32 @@ current sheet: 0:01:00 (a timesheet that is running)
 
         it "should allow the sheet to be stopped at a certain time" do
           invoke 'out --at "10am 2008-10-03"'
-          Timetrap::Entry.order_by(:id).last.end.should == Time.parse('2008-10-03 10:00')
+          @active.refresh.end.should == Time.parse('2008-10-03 10:00')
         end
-      end
 
-      describe "running" do
-        it "should show all running timesheets" do
-          create_entry :sheet => 'one', :end => nil
-          create_entry :sheet => 'two', :end => nil
-          create_entry :sheet => 'three'
-          invoke 'running'
-          $stdout.string.should == "Running Timesheets:\n  one: note\n  two: note\n"
-        end
-        it "should show no runnig timesheets" do
-          invoke 'running'
-          $stdout.string.should == "Running Timesheets:\n"
+        it "should allow you to check out of a non active sheet" do
+          invoke 'sheet SomeOtherSheet'
+          invoke 'in'
+          @new_active = Timetrap::Timer.active_entry
+          @active.should_not == @new_active
+          invoke %'out #{@active.sheet} --at "10am 2008-10-03"'
+          @active.refresh.end.should == Time.parse('2008-10-03 10:00')
+          @new_active.refresh.end.should be_nil
         end
       end
 
-      describe "switch" do
+      describe "sheet" do
         it "should switch to a new timesheet" do
-          invoke 'switch sheet 1'
-          Timetrap.current_sheet.should == 'sheet 1'
-          invoke 'switch sheet 2'
-          Timetrap.current_sheet.should == 'sheet 2'
+          invoke 'sheet sheet 1'
+          Timetrap::Timer.current_sheet.should == 'sheet 1'
+          invoke 'sheet sheet 2'
+          Timetrap::Timer.current_sheet.should == 'sheet 2'
         end
 
         it "should not switch to an blank timesheet" do
-          invoke 'switch sheet 1'
-          invoke 'switch'
-          Timetrap.current_sheet.should == 'sheet 1'
+          invoke 'sheet sheet 1'
+          invoke 'sheet'
+          Timetrap::Timer.current_sheet.should == 'sheet 1'
         end
       end
     end
@@ -542,7 +586,7 @@ current sheet: 0:01:00 (a timesheet that is running)
   describe "entries" do
     it "should give the entires for a sheet" do
       e = create_entry :sheet => 'sheet'
-      Timetrap.entries('sheet').all.should include(e)
+      Timetrap::Timer.entries('sheet').all.should include(e)
     end
 
   end
@@ -550,9 +594,9 @@ current sheet: 0:01:00 (a timesheet that is running)
   describe "start" do
     it "should start an new entry" do
       @time = Time.now
-      Timetrap.current_sheet = 'sheet1'
+      Timetrap::Timer.current_sheet = 'sheet1'
       lambda do
-        Timetrap.start 'some work', @time
+        Timetrap::Timer.start 'some work', @time
       end.should change(Timetrap::Entry, :count).by(1)
       Timetrap::Entry.order(:id).last.sheet.should == 'sheet1'
       Timetrap::Entry.order(:id).last.note.should == 'some work'
@@ -561,156 +605,149 @@ current sheet: 0:01:00 (a timesheet that is running)
     end
 
     it "should be running if it is started" do
-      Timetrap.should_not be_running
-      Timetrap.start 'some work', @time
-      Timetrap.should be_running
+      Timetrap::Timer.should_not be_running
+      Timetrap::Timer.start 'some work', @time
+      Timetrap::Timer.should be_running
     end
 
-    it "should raise and error if it is already running" do
+    it "should raise an error if it is already running" do
       lambda do
-        Timetrap.start 'some work', @time
-        Timetrap.start 'some work', @time
-      end.should change(Timetrap::Entry, :count).by(1)
+        Timetrap::Timer.start 'some work', @time
+        Timetrap::Timer.start 'some work', @time
+      end.should raise_error(Timetrap::Timer::AlreadyRunning)
     end
   end
 
   describe "stop" do
     it "should stop a new entry" do
       @time = Time.now
-      Timetrap.start 'some work', @time
-      entry = Timetrap.active_entry
+      Timetrap::Timer.start 'some work', @time
+      entry = Timetrap::Timer.active_entry
       entry.end.should be_nil
-      Timetrap.stop @time
+      Timetrap::Timer.stop Timetrap::Timer.current_sheet, @time
       entry.refresh.end.to_i.should == @time.to_i
     end
 
     it "should not be running if it is stopped" do
-      Timetrap.should_not be_running
-      Timetrap.start 'some work', @time
-      Timetrap.stop
-      Timetrap.should_not be_running
+      Timetrap::Timer.should_not be_running
+      Timetrap::Timer.start 'some work', @time
+      Timetrap::Timer.stop Timetrap::Timer.current_sheet
+      Timetrap::Timer.should_not be_running
     end
 
     it "should not stop it twice" do
-      Timetrap.start 'some work'
-      e = Timetrap.active_entry
-      Timetrap.stop
+      Timetrap::Timer.start 'some work'
+      e = Timetrap::Timer.active_entry
+      Timetrap::Timer.stop Timetrap::Timer.current_sheet
       time = e.refresh.end
-      Timetrap.stop
+      Timetrap::Timer.stop Timetrap::Timer.current_sheet
       time.to_i.should == e.refresh.end.to_i
     end
 
   end
 
-  describe 'switch' do
-    it "should switch to a new sheet" do
-      Timetrap.switch 'sheet1'
-      Timetrap.current_sheet.should == 'sheet1'
-      Timetrap.switch 'sheet2'
-      Timetrap.current_sheet.should == 'sheet2'
-    end
-  end
 
-end
-
-describe Timetrap::Entry do
-
-  include Timetrap::StubConfig
-  describe "with an instance" do
-    before do
-      @time = Time.now
-      @entry = Timetrap::Entry.new
-    end
+  describe Timetrap::Entry do
 
-    describe 'attributes' do
-      it "should have a note" do
-        @entry.note = "world takeover"
-        @entry.note.should == "world takeover"
+    include Timetrap::StubConfig
+    describe "with an instance" do
+      before do
+        @time = Time.now
+        @entry = Timetrap::Entry.new
       end
 
-      it "should have a start" do
-        @entry.start = @time
-        @entry.start.to_i.should == @time.to_i
+      describe '.sheets' do
+        it "should output a list of all the available sheets" do
+          Timetrap::Entry.create( :sheet => 'another',
+            :note => 'entry 4', :start => '2008-10-05 18:00:00'
+          )
+          Timetrap::Entry.create( :sheet => 'SpecSheet',
+            :note => 'entry 2', :start => '2008-10-03 16:00:00', :end => '2008-10-03 18:00:00'
+          )
+          Timetrap::Entry.sheets.should == %w(another SpecSheet).sort
+        end
       end
 
-      it "should have a end" do
-        @entry.end = @time
-        @entry.end.to_i.should == @time.to_i
-      end
 
-      it "should have a sheet" do
-        @entry.sheet= 'name'
-        @entry.sheet.should == 'name'
-      end
+      describe 'attributes' do
+        it "should have a note" do
+          @entry.note = "world takeover"
+          @entry.note.should == "world takeover"
+        end
+
+        it "should have a start" do
+          @entry.start = @time
+          @entry.start.to_i.should == @time.to_i
+        end
 
-      def with_rounding_on
-        old_val = Timetrap::Entry.round
-        begin
-          Timetrap::Entry.round = true
-          block_return_value = yield
-        ensure
-          Timetrap::Entry.round = old_val
+        it "should have a end" do
+          @entry.end = @time
+          @entry.end.to_i.should == @time.to_i
         end
-      end
 
-      it "should use round start if the global round attribute is set" do
-        with_rounding_on do
-          with_stubbed_config('round_in_seconds' => 900) do
-            @time = Chronic.parse("12:55am")
-            @entry.start = @time
-            @entry.start.should == Chronic.parse("1am")
+        it "should have a sheet" do
+          @entry.sheet= 'name'
+          @entry.sheet.should == 'name'
+        end
+
+        def with_rounding_on
+          old_val = Timetrap::Entry.round
+          begin
+            Timetrap::Entry.round = true
+            block_return_value = yield
+          ensure
+            Timetrap::Entry.round = old_val
           end
         end
-      end
 
-      it "should use round start if the global round attribute is set" do
-        with_rounding_on do
+        it "should use round start if the global round attribute is set" do
+          with_rounding_on do
+            with_stubbed_config('round_in_seconds' => 900) do
+              @time = Chronic.parse("12:55am")
+              @entry.start = @time
+              @entry.start.should == Chronic.parse("1am")
+            end
+          end
+        end
+
+        it "should use round start if the global round attribute is set" do
+          with_rounding_on do
+            with_stubbed_config('round_in_seconds' => 900) do
+              @time = Chronic.parse("12:50am")
+              @entry.start = @time
+              @entry.start.should == Chronic.parse("12:45am")
+            end
+          end
+        end
+
+        it "should have a rounded start" do
           with_stubbed_config('round_in_seconds' => 900) do
             @time = Chronic.parse("12:50am")
             @entry.start = @time
-            @entry.start.should == Chronic.parse("12:45am")
+            @entry.rounded_start.should == Chronic.parse("12:45am")
           end
         end
-      end
 
-      it "should have a rounded start" do
-        with_stubbed_config('round_in_seconds' => 900) do
-          @time = Chronic.parse("12:50am")
-          @entry.start = @time
-          @entry.rounded_start.should == Chronic.parse("12:45am")
+        it "should not round nil times" do
+          @entry.start = nil
+          @entry.rounded_start.should be_nil
         end
       end
 
-      it "should not round nil times" do
-        @entry.start = nil
-        @entry.rounded_start.should be_nil
-      end
-    end
-
-    describe "parsing natural language times" do
-      it "should set start time using english" do
-        @entry.start = "yesterday 10am"
-        @entry.start.should_not be_nil
-        @entry.start.should == Chronic.parse("yesterday 10am")
-      end
+      describe "parsing natural language times" do
+        it "should set start time using english" do
+          @entry.start = "yesterday 10am"
+          @entry.start.should_not be_nil
+          @entry.start.should == Chronic.parse("yesterday 10am")
+        end
 
-      it "should set end time using english" do
-        @entry.end = "tomorrow 1pm"
-        @entry.end.should_not be_nil
-        @entry.end.should == Chronic.parse("tomorrow 1pm")
+        it "should set end time using english" do
+          @entry.end = "tomorrow 1pm"
+          @entry.end.should_not be_nil
+          @entry.end.should == Chronic.parse("tomorrow 1pm")
+        end
       end
     end
-  end
 
-  describe '::sheets' do
-    it "should output a list of all the available sheets" do
-      Timetrap::Entry.create( :sheet => 'another',
-        :note => 'entry 4', :start => '2008-10-05 18:00:00'
-      )
-      Timetrap::Entry.create( :sheet => 'SpecSheet',
-        :note => 'entry 2', :start => '2008-10-03 16:00:00', :end => '2008-10-03 18:00:00'
-      )
-      Timetrap::Entry.sheets.should == %w(another SpecSheet).sort
-    end
   end
 end