samg-timetrap 0.0.1

data/README

@@ -0,0 +1,148 @@
+Timetrap
+========
+
+Timetrap is a ruby port of Trevor Caira's Timebook, a small utility which aims
+to be a low-overhead way of tracking what you spend time on.  Timetrap
+maintains its state in a sqlite3 database.
+
+To install:
+  $ gem sources -a http://gems.github.com (you only have to do this once)
+  $ sudo gem install samg-timetrap
+
+This will place a ``t`` executable in your path.
+
+Original Timebook available at:
+http://bitbucket.org/trevor/timebook/src/
+
+
+Concepts
+~~~~~~~~
+
+Timetrap maintains a list of *timesheets* -- distinct lists of timed *periods*.
+Each period has a start and end time, with the exception of the most recent
+period, which may have no end time set. This indicates that this period is
+still running. Timesheets containing such periods are considered *active*. It
+is possible to have multiple timesheets active simultaneously, though a single
+time sheet may only have one period running at once.
+
+Interactions with timetrap are performed through the ``t`` command on the
+command line. ``t`` is followed by one of timetrap's subcommands.  Often used
+subcommands include ``in``, ``out``, ``switch``, ``now``, ``list`` and
+``display``. Commands may be abbreviated as long as they are unambiguous: thus
+``t switch foo`` and ``t s foo`` are identical.  With the default command set,
+no two commands share the first same letter, thus it is only necessary to type
+the first letter of a command.  Likewise, commands which display timesheets
+accept abbreviated timesheet names. ``t display f`` is thus equivalent to ``t
+display foo`` if ``foo`` is the only timesheet which begins with "f". Note that
+this does not apply to ``t switch``, since this command also creates
+timesheets.  (Using the earlier example, if ``t switch f`` is entered, it would
+thus be ambiguous whether a new timesheet ``f`` or switching to the existing
+timesheet ``foo`` was desired).
+
+Usage
+~~~~~
+
+The basic usage is as follows::
+
+  $ t switch writing
+  $ t in document timetrap --at "10 minutes ago"
+  $ t out
+
+The first command, ``t switch writing``, switches to the timesheet "writing"
+(or creates it if it does not exist). ``t in document timetrap --at "10 minutes
+ago"`` creates a new period in the current timesheet, and annotates it with the
+description "document timetrap". The optional --at flag can be passed to start
+the entry at a time other than the present.  Any Chronic or database parsable
+strings are accepted  Note that this command would be in error if the
+``writing`` timesheet was already active.  Finally, ``t out`` records the
+current time as the end time for the most recent period in the ``writing``
+timesheet.
+
+To display the current timesheet, invoke the ``t display`` command::
+
+  $ t display
+  Timesheet writing:
+  Day            Start      End        Duration   Notes
+  Mar 14, 2009   19:53:30 - 20:06:15   0:12:45    document timetrap
+                 20:07:02 -            0:00:01    write home about timetrap
+                                       0:12:46
+  Total                                0:12:46
+
+Each period in the timesheet is listed on a row. If the timesheet is active,
+the final period in the timesheet will have no end time. After each day, the
+total time tracked in the timesheet for that day is listed. Note that this is
+computed by summing the durations of the periods beginning in the day. In the
+last row, the total time tracked in the timesheet is shown.
+
+Commands
+~~~~~~~~
+
+**alter**
+  Inserts a note associated with the currently active period in the timesheet.
+
+  usage: ``t alter NOTES...``
+
+**backend**
+  Run an interactive database session on the timetrap database. Requires the
+  sqlite3 command.
+
+  usage: ``t backend``
+
+**display**
+  Display a given timesheet. If no timesheet is specified, show the current
+  timesheet.
+
+  usage: ``t display [TIMESHEET]``
+
+**format**
+  Export the current sheet as a comma-separated value format spreadsheet.  If
+  the final entry is active, it is ignored.
+
+  If a specific timesheet is given, display the same information for that
+  timesheet instead.
+
+  usage: ``t format [--start DATE] [--end DATE] [TIMESHEET]``
+
+**in**
+  Start the timer for the current timesheet. Must be called before out.  Notes
+  may be specified for this period. This is exactly equivalent to
+  ``t in; t alter NOTES``
+
+  usage: ``t in [--at TIME] [NOTES...]``
+
+**kill**
+  Delete a timesheet. If no timesheet is specified, delete the current
+  timesheet and switch to the default timesheet.
+
+  usage: ``t kill [TIMESHEET]``
+
+**list**
+  List the available timesheets.
+
+  usage: ``t list``
+
+**now**
+  Print the current sheet, whether it's active, and if so, how long it has been
+  active and what notes are associated with the current period.
+
+  If a specific timesheet is given, display the same information for that
+  timesheet instead.
+
+  usage: ``t now``
+
+**out**
+  Stop the timer for the current timesheet. Must be called after in.
+
+  usage: ``t in [--at TIME]``
+
+**running**
+  Print all active sheets and any messages associated with them.
+
+  usage: ``t running``
+
+**switch**
+  Switch to a new timesheet. this causes all future operation (except switch)
+  to operate on that timesheet. The default timesheet is called "default".
+
+  usage: ``t switch TIMESHEET``
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => :spec
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.include("README", "**/*.rb")
+end

data/bin/t

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'timetrap'
+Timetrap::CLI.invoke

data/lib/timetrap.rb

@@ -0,0 +1,317 @@
+require 'rubygems'
+require 'chronic'
+require 'sequel'
+require 'Getopt/Declare'
+# connect to database.  This will create one if it doesn't exist
+DB_NAME = defined?(TEST_MODE) ? nil : "#{ENV['HOME']}/.timetrap.db"
+DB = Sequel.sqlite DB_NAME
+
+module Timetrap
+  extend self
+
+  module CLI
+    attr_accessor :args
+    extend self
+
+    COMMANDS = {
+      "alter" => "alter the description of the active period",
+      "backend" => "open an the backend's interactive shell",
+      "display" => "display the current timesheet",
+      "format" => "export a sheet to csv format",
+      "in" => "start the timer for the current timesheet",
+      "kill" => "delete a timesheet",
+      "list" => "show the available timesheets",
+      "now" => "show the status of the current timesheet",
+      "out" => "stop the timer for the current timesheet",
+      "running" => "show all running timesheets",
+      "switch" => "switch to a new timesheet"
+    }
+
+    def parse arguments
+      args.parse arguments
+    end
+
+    def invoke
+      invoke_command_if_valid
+    end
+
+    def invoke_command_if_valid
+      command = args.unused.shift
+      case (valid = COMMANDS.keys.select{|name| name =~ %r|^#{command}|}).size
+      when 0 then say "Invalid command: #{command}"
+      when 1 then send valid[0]
+      else; say "Ambigous command: #{command}"; end
+    end
+
+    def alter
+      Timetrap.active_entry.update :note => args.unused.join(' ')
+    end
+
+    def backend
+      exec "sqlite3 #{DB_NAME}"
+    end
+
+    def in
+      Timetrap.start args.unused.join(' '), args['--at']
+    end
+
+    def out
+      Timetrap.stop args['--at']
+    end
+
+    def kill
+      sheet = args.unused.join(' ')
+      unless (sheets = Entry.map{|e| e.sheet }.uniq).include?(sheet)
+        say "ain't no sheet #{sheet.inspect}", 'sheets:', *sheets
+        return
+      end
+      victims = Entry.filter(:sheet => sheet).count
+      print "are you sure you want to delete #{victims} entries on sheet #{sheet.inspect}? "
+      if $stdin.gets =~ /\Aye?s?\Z/i
+        Timetrap.kill sheet
+        say "killed #{victims} entries"
+      else
+        say "will not kill"
+      end
+    end
+
+    def display
+      sheet = sheet_name_from_string(args.unused.join(' '))
+      sheet = (sheet =~ /.+/ ? sheet : Timetrap.current_sheet)
+      say "Timesheet: #{sheet}"
+      say "           Day                Start      End        Duration   Notes"
+      last_start = nil
+      from_current_day = []
+      (ee = Timetrap.entries(sheet)).each_with_index do |e, i|
+
+
+        from_current_day << e
+        e_end = e.end || Time.now
+        say "%27s%11s -%9s%10s    %s" % [
+          format_date_if_new(e.start, last_start),
+          format_time(e.start),
+          format_time(e.end),
+          format_duration(e.start, e_end),
+          e.note
+        ]
+
+        nxt = Timetrap.entries(sheet).map[i+1]
+        if nxt == nil or !same_day?(e.start, nxt.start)
+          say "%59s" % format_total(from_current_day)
+          from_current_day = []
+        else
+        end
+        last_start = e.start
+      end
+      say <<-OUT
+           ---------------------------------------------------------
+      OUT
+      say "           Total%43s" % format_total(ee)
+    end
+
+    def format
+      say "Sorry not implemented yet :-("
+    end
+
+    def switch
+      sheet = args.unused.join(' ')
+      if not sheet then say "No sheet specified"; return end
+      say "Switching to sheet " + Timetrap.switch(sheet)
+    end
+
+    def list
+      sheets = Entry.map{|e|e.sheet}.uniq.sort.map do |sheet|
+        sheet_atts = {:total => 0, :running => 0, :today => 0}
+        DB[:entries].filter(:sheet => sheet).inject(sheet_atts) do |m, e|
+          e_end = e[:end] || Time.now
+          m[:name] ||= sheet
+          m[:total] += (e_end.to_i - e[:start].to_i)
+          m[:running] += (e_end.to_i - e[:start].to_i) unless e[:end]
+          m[:today] += (e_end.to_i - e[:start].to_i) if same_day?(Time.now, e[:start])
+          m
+        end
+      end
+      width = sheets.sort_by{|h|h[:name].length }.last[:name].length + 4
+      say " %-#{width}s%-12s%-12s%s" % ["Timesheet", "Running", "Today", "Total Time"]
+      sheets.each do |sheet|
+        star = sheet[:name] == Timetrap.current_sheet ? '*' : ' '
+        say "#{star}%-#{width}s%-12s%-12s%s" % [
+          sheet[:running],
+          sheet[:today],
+          sheet[:total]
+        ].map(&method(:format_seconds)).unshift(sheet[:name])
+      end
+    end
+
+    def now
+      if Timetrap.running?
+        out = "#{Timetrap.current_sheet}: #{format_duration(Timetrap.active_entry.start, Time.now)}".gsub(/  /, ' ')
+        out << " (#{Timetrap.active_entry.note})" if Timetrap.active_entry.note =~ /.+/
+        say out
+      else
+        say "#{Timetrap.current_sheet}: not running"
+      end
+    end
+
+
+    private
+
+    def format_time time
+      return '' unless time.respond_to?(:strftime)
+      time.strftime('%H:%M:%S')
+    end
+
+    def format_date time
+      return '' unless time.respond_to?(:strftime)
+      time.strftime('%a %b %d, %Y')
+    end
+
+    def format_date_if_new time, last_time
+      return '' unless time.respond_to?(:strftime)
+      same_day?(time, last_time) ? '' : format_date(time)
+    end
+
+    def same_day? time, other_time
+      format_date(time) == format_date(other_time)
+    end
+
+    def format_duration stime, etime
+      return '' unless stime and etime
+      secs = etime.to_i - stime.to_i
+      format_seconds secs
+    end
+
+    def format_seconds secs
+      "%2s:%02d:%02d" % [secs/3600, (secs%3600)/60, secs%60]
+    end
+
+    def format_total entries
+      secs = entries.inject(0){|m, e|e_end = e.end || Time.now; m += e_end.to_i - e.start.to_i if e_end && e.start;m}
+      "%2s:%02d:%02d" % [secs/3600, (secs%3600)/60, secs%60]
+    end
+
+    def sheet_name_from_string string
+      return "" unless string =~ /.+/
+      DB[:entries].filter(:sheet.like("#{string}%")).first[:sheet]
+    rescue
+      ""
+    end
+
+    public
+    def say *something
+      puts *something
+    end
+  end
+
+  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 invoked_as_executable?
+    $0 == __FILE__
+  end
+
+  def entries sheet = nil
+    Entry.filter(:sheet => sheet).order_by(:start)
+  end
+
+  def running?
+    !!active_entry
+  end
+
+  def active_entry
+    Entry.find(:sheet => Timetrap.current_sheet, :end => nil)
+  end
+
+  def stop time = nil
+    while a = active_entry
+      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 => Timetrap.current_sheet, :note => note, :start => time).save
+  rescue => e
+    CLI.say e.message
+  end
+
+  def switch sheet
+    self.current_sheet = sheet
+  end
+
+  def kill sheet
+    Entry.filter(:sheet => sheet).destroy
+  end
+
+  class AlreadyRunning < StandardError
+    def message
+      "Timetrap is already running"
+    end
+  end
+
+
+  class Entry < Sequel::Model
+    plugin :schema
+
+    def start= time
+      self[:start]= Chronic.parse(time) || time
+    end
+
+    def end= time
+      self[:end]= Chronic.parse(time) || time
+    end
+
+    # do a quick pseudo migration.  This should only get executed on the first run
+    set_schema do
+      primary_key :id
+      column :note, :string
+      column :start, :timestamp
+      column :end, :timestamp
+      column :sheet, :string
+    end
+    create_table unless table_exists?
+  end
+
+  class Meta < Sequel::Model(:meta)
+    plugin :schema
+
+    set_schema do
+      primary_key :id
+      column :key, :string
+      column :value, :string
+    end
+    create_table unless table_exists?
+  end
+  CLI.args = Getopt::Declare.new(<<-EOF)
+Usage: #{File.basename $0} COMMAND [OPTIONS] [ARGS...]
+
+where COMMAND is one of:
+  alter - alter the description of the active period
+  backend - open an the backend's interactive shell
+  display - display the current timesheet
+  format - export a sheet to csv format
+  in - start the timer for the current timesheet
+  kill - delete a timesheet
+  list - show the available timesheets
+  now - show the status of the current timesheet
+  out - stop the timer for the current timesheet
+  running - show all running timesheets
+  switch - switch to a new timesheet
+
+  COMMAND OPTIONS
+  -a, --at <time:qs>        Use this time instead of now
+  EOF
+end

data/spec/timetrap_spec.rb

@@ -0,0 +1,373 @@
+TEST_MODE = true
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timetrap')
+require 'spec'
+
+describe Timetrap do
+  def create_entry atts = {}
+    Timetrap::Entry.create({
+      :sheet => 's1',
+      :start => Time.now,
+      :end => Time.now,
+      :note => 'note'}.merge(atts))
+  end
+
+  before :each do
+    Timetrap::Entry.create_table!
+    Timetrap::Meta.create_table!
+    $stdout = StringIO.new
+    $stdin = StringIO.new
+  end
+
+  describe 'CLI' do
+    describe "COMMANDS" do
+      def invoke command
+        Timetrap::CLI.parse command
+        Timetrap::CLI.invoke
+      end
+
+      describe 'alter' do
+        before do
+          Timetrap.start "running entry", nil
+        end
+        it "should alter the description of the active period" do
+          Timetrap.active_entry.note.should == 'running entry'
+          invoke 'alter new description'
+          Timetrap.active_entry.note.should == 'new description'
+        end
+      end
+
+      describe "backend" do
+        it "should open an sqlite console to the db" do
+          Timetrap::CLI.should_receive(:exec).with("sqlite3 #{DB_NAME}")
+          invoke 'backend'
+        end
+      end
+
+      describe "display" do
+        before 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.create( :sheet => 'SpecSheet',
+            :note => 'entry 1', :start => '2008-10-03 12:00:00', :end => '2008-10-03 14:00:00'
+          )
+          Timetrap::Entry.create( :sheet => 'SpecSheet',
+            :note => 'entry 3', :start => '2008-10-05 16:00:00', :end => '2008-10-05 18:00:00'
+          )
+          Timetrap::Entry.create( :sheet => 'SpecSheet',
+            :note => 'entry 4', :start => '2008-10-05 18:00:00'
+          )
+
+          Time.stub!(:now).and_return Time.at(1223254800 + (60*60*2))
+          @desired_output = <<-OUTPUT
+Timesheet: SpecSheet
+           Day                Start      End        Duration   Notes
+           Fri Oct 03, 2008   12:00:00 - 14:00:00   2:00:00    entry 1
+                              16:00:00 - 18:00:00   2:00:00    entry 2
+                                                    4:00:00
+           Sun Oct 05, 2008   16:00:00 - 18:00:00   2:00:00    entry 3
+                              18:00:00 -            2:00:00    entry 4
+                                                    4:00:00
+           ---------------------------------------------------------
+           Total                                    8:00:00
+          OUTPUT
+        end
+
+        it "should display the current timesheet" do
+          Timetrap.current_sheet = 'SpecSheet'
+          invoke 'display'
+          $stdout.string.should == @desired_output
+        end
+
+        it "should display a non current timesheet" do
+          Timetrap.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'
+          invoke 'display S'
+          $stdout.string.should == @desired_output
+        end
+      end
+
+      describe "format" do
+        it "should export a sheet to a csv format" do
+          pending
+        end
+      end
+
+      describe "in" do
+        it "should start the time for the current timesheet" do
+          lambda do
+            invoke 'in'
+          end.should change(Timetrap::Entry, :count).by(1)
+        end
+
+        it "should set the note when starting a new entry" do
+          invoke 'in working on something'
+          Timetrap::Entry.order_by(:id).last.note.should == 'working on something'
+        end
+
+        it "should set the start when starting a new entry" do
+          @time = Time.now
+          Time.stub!(:now).and_return @time
+          invoke 'in working on something'
+          Timetrap::Entry.order_by(:id).last.start.to_i.should == @time.to_i
+        end
+
+        it "should not start the time if the timetrap is running" do
+          Timetrap.stub!(:running?).and_return true
+          lambda do
+            invoke 'in'
+          end.should_not change(Timetrap::Entry, :count)
+        end
+
+        it "should allow the sheet to be started at a certain time" do
+          invoke 'in work --at "10am 2008-10-03"'
+          Timetrap::Entry.order_by(:id).last.start.should == Time.parse('2008-10-03 10:00')
+        end
+      end
+
+      describe "kill" do
+        it "should give me a chance not to fuck up" do
+          entry = create_entry
+          lambda do
+            $stdin.string = ""
+            invoke "kill #{entry.sheet}"
+          end.should_not change(Timetrap::Entry, :count).by(-1)
+        end
+
+        it "should delete a timesheet" do
+          entry = create_entry
+          lambda do
+            $stdin.string = "yes\n"
+            invoke "kill #{entry.sheet}"
+          end.should change(Timetrap::Entry, :count).by(-1)
+        end
+      end
+
+      describe "list" do
+        before do
+          Time.stub!(:now).and_return Time.parse("Oct 5 18:00:00 -0700 2008")
+          create_entry( :sheet => 'A Longly Named Sheet 2', :start => '2008-10-03 12:00:00',
+                       :end => '2008-10-03 14:00:00')
+          create_entry( :sheet => 'A Longly Named Sheet 2', :start => '2008-10-03 12:00:00',
+                       :end => '2008-10-03 14:00:00')
+          create_entry( :sheet => 'A Longly Named Sheet 2', :start => '2008-10-05 12:00:00',
+                       :end => '2008-10-05 14:00:00')
+          create_entry( :sheet => 'A Longly Named Sheet 2', :start => '2008-10-05 14:00:00',
+                       :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'
+        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
+      end
+
+      describe "now" do
+        before do
+          Timetrap.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
+            OUTPUT
+          end
+        end
+
+        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))
+            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)
+            OUTPUT
+          end
+        end
+      end
+
+      describe "out" do
+        before :each do
+          invoke 'in'
+          @active = Timetrap.active_entry
+          @now = Time.now
+          Time.stub!(:now).and_return @now
+        end
+        it "should set the stop for the running entry" do
+          @active.refresh.end.should == nil
+          invoke 'out'
+          @active.refresh.end.to_i.should == @now.to_i
+        end
+
+        it "should not do anything if nothing is running" do
+          lambda do
+            invoke 'out'
+            invoke 'out'
+          end.should_not raise_error
+        end
+
+        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')
+        end
+      end
+
+      describe "running" do
+        before do
+          create_entry :sheet => 'one', :end => nil
+          create_entry :sheet => 'two', :end => nil
+        end
+        it "should show all running timesheets" do
+
+
+        end
+      end
+
+      describe "switch" 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'
+        end
+      end
+    end
+  end
+
+  describe "entries" do
+    it "should give the entires for a sheet" do
+      e = create_entry :sheet => 'sheet'
+      Timetrap.entries('sheet').all.should include(e)
+    end
+
+  end
+
+  describe "start" do
+    it "should start an new entry" do
+      @time = Time.now
+      Timetrap.current_sheet = 'sheet1'
+      lambda do
+        Timetrap.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'
+      Timetrap::Entry.order(:id).last.start.to_i.should == @time.to_i
+      Timetrap::Entry.order(:id).last.end.should be_nil
+    end
+
+    it "should be running if it is started" do
+      Timetrap.should_not be_running
+      Timetrap.start 'some work', @time
+      Timetrap.should be_running
+    end
+
+    it "should raise and 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)
+    end
+  end
+
+  describe "stop" do
+    it "should stop a new entry" do
+      @time = Time.now
+      Timetrap.start 'some work', @time
+      entry = Timetrap.active_entry
+      entry.end.should be_nil
+      Timetrap.stop @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
+    end
+
+    it "should not stop it twice" do
+      Timetrap.start 'some work'
+      e = Timetrap.active_entry
+      Timetrap.stop
+      time = e.refresh.end
+      Timetrap.stop
+      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
+  before do
+    @time = Time.now
+    @entry = Timetrap::Entry.new
+  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.should == @time
+    end
+
+    it "should have a end" do
+      @entry.end = @time
+      @entry.end.should == @time
+    end
+
+    it "should have a sheet" do
+      @entry.sheet= 'name'
+      @entry.sheet.should == 'name'
+    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
+
+    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

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: samg-timetrap
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sam Goldstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.12.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: chronic
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: getopt-declare
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.28"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.15"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.2
+    version: 
+description: Command line time tracker
+email: sgrock@gmail.com
+executables: 
+- t
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/timetrap.rb
+- bin/t
+- spec/timetrap_spec.rb
+has_rdoc: true
+homepage: http://github.com/samg/timetrap/tree/master
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Command line time tracker
+test_files: []
+