samg-timetrap 0.0.7 → 0.0.8

data/bin/dev_t

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# Executable with absolute path to lib for hacking and development
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timetrap')
+Timetrap::CLI.invoke

data/lib/timetrap/cli.rb

@@ -0,0 +1,227 @@
+module Timetrap
+  module CLI
+    extend Helpers
+    attr_accessor :args
+    extend self
+
+    USAGE = <<-EOF
+
+Timetrap - Simple Time Tracking
+
+Usage: #{File.basename $0} COMMAND [OPTIONS] [ARGS...]
+
+where COMMAND is one of:
+  * alter - alter an entry's note, start, or end time. Defaults to the active entry
+    usage: t alter [--id ID] [--start TIME] [--end TIME] [NOTES]
+    -i, --id <id:i>           Alter entry with id <id> instead of the running entry
+    -s, --start <time:qs>     Change the start time to <time>
+    -e, --end <time:qs>       Change the end time to <time>
+  * backend - open an sqlite shell to the database
+    usage: t backend
+  * display - display the current timesheet
+    usage: t display [--ids] [--start DATE] [--end DATE] [TIMESHEET]
+    -v, --ids                 Print database ids (for use with alter)
+    -s, --start <date:qs>     Include entries that start on this date or later
+    -e, --end <date:qs>       Include entries that start on this date or earlier
+  * format - export a sheet to csv format
+    usage: t format [--ids] [--start DATE] [--end DATE] FORMATTER
+    FORMATTER                 Currently only supports 'ical'
+    -s, --start <date:qs>     Include entries that start on this date or later
+    -e, --end <date:qs>       Include entries that start on this date or earlier
+  * in - start the timer for the current timesheet
+    usage: t in [--at TIME] [NOTES]
+    -a, --at <time:qs>        Use this time instead of now
+  * kill - delete a timesheet
+    usage: t kill [--id ID] [TIMESHEET]
+    -i, --id <id:i>           Alter entry with id <id> instead of the running entry
+  * list - show the available timesheets
+    usage: t list
+  * now - show the status of the current timesheet
+    usage: t now
+  * out - stop the timer for the current timesheet
+    usage: t out [--at TIME]
+    -a, --at <time:qs>        Use this time instead of now
+  * running - show all running timesheets
+    NOT IMPLEMENTED
+  * switch - switch to a new timesheet
+    usage: t switch TIMESHEET
+
+    OTHER OPTIONS
+    -h, --help     Display this help
+    EOF
+
+    def parse arguments
+      args.parse arguments
+    end
+
+    def invoke
+      args['-h'] ? say(USAGE) : invoke_command_if_valid
+    end
+
+    def commands
+      Timetrap::CLI::USAGE.scan(/\* \w+/).map{|s| s.gsub(/\* /, '')}
+    end
+
+    def say *something
+      puts *something
+    end
+
+    def invoke_command_if_valid
+      command = args.unused.shift
+      case (valid = commands.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
+      entry = args['-i'] ? Entry[args['-i']] : Timetrap.active_entry
+      say "can't find entry" && return unless entry
+      entry.update :start => args['-s'] if args['-s'] =~ /.+/
+      entry.update :end => args['-e'] if args['-e'] =~ /.+/
+      entry.update :note => unused_args if unused_args =~ /.+/
+    end
+
+    def backend
+      exec "sqlite3 #{DB_NAME}"
+    end
+
+    def in
+      Timetrap.start unused_args, args['-a']
+    end
+
+    def out
+      Timetrap.stop args['-a']
+    end
+
+    def kill
+      if e = Entry[args['-i']]
+        out = "are you sure you want to delete entry #{e.id}? "
+        out << "(#{e.note}) " if e.note.to_s =~ /.+/
+        print out
+        if $stdin.gets =~ /\Aye?s?\Z/i
+          e.destroy
+          say "it's dead"
+        else
+          say "will not kill"
+        end
+      elsif (sheets = Entry.map{|e| e.sheet }.uniq).include?(sheet = unused_args)
+        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 sheet
+          say "killed #{victims} entries"
+        else
+          say "will not kill"
+        end
+      else
+        victim = args['-i'] ? args['-i'].to_s.inspect : sheet.inspect
+        say "can't find #{victim} to kill", 'sheets:', *sheets
+      end
+    end
+
+    def display
+      sheet = sheet_name_from_string(unused_args)
+      sheet = (sheet =~ /.+/ ? sheet : Timetrap.current_sheet)
+      say "Timesheet: #{sheet}"
+      id_heading = args['-v'] ? 'Id' : '  '
+      say "#{id_heading}  Day                Start      End        Duration   Notes"
+      last_start = nil
+      from_current_day = []
+      ee = Timetrap::Entry.filter(:sheet => sheet).order(:start)
+      ee = ee.filter(:end >= Date.parse(args['-s'])) if args['-s']
+      ee = ee.filter(:start <= Date.parse(args['-e']) + 1) if args['-e']
+      ee.each_with_index do |e, i|
+
+
+        from_current_day << e
+        e_end = e.end || Time.now
+        say "%-4s%16s%11s -%9s%10s    %s" % [
+          (args['-v'] ? e.id : ''),
+          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 = ee.map[i+1]
+        if nxt == nil or !same_day?(e.start, nxt.start)
+          say "%52s" % 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
+
+    # TODO: Consolidate display and format
+    def format
+      begin
+        fmt_klass = Timetrap::Formatters.const_get("#{unused_args.classify}")
+      rescue
+        say "Invalid format specified `#{unused_args}'"
+        return
+      end
+      ee = Timetrap::Entry.filter(:sheet => Timetrap.current_sheet)
+      ee = ee.filter(:end >= Date.parse(args['-s'])) if args['-s']
+      ee = ee.filter(:start <= Date.parse(args['-e']) + 1) if args['-e']
+      say Timetrap.format(fmt_klass,ee.all)
+    end
+
+    def switch
+      sheet = unused_args
+      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
+
+    def running
+      say "Sorry not implemented yet :-("
+    end
+
+    private
+
+    def unused_args
+      args.unused.join(' ')
+    end
+
+  end
+end

data/lib/timetrap/helpers.rb

@@ -0,0 +1,44 @@
+module Timetrap
+  module Helpers
+    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
+  end
+end

data/lib/timetrap/models.rb

@@ -0,0 +1,34 @@
+module Timetrap
+  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
+end

data/lib/timetrap.rb

@@ -1,262 +1,20 @@
 require 'rubygems'
 require 'chronic'
 require 'sequel'
+require 'sequel/extensions/inflector'
 require 'Getopt/Declare'
-# connect to database.  This will create one if it doesn't exist
+require File.join(File.dirname(__FILE__), 'timetrap', 'helpers')
+require File.join(File.dirname(__FILE__), 'timetrap', 'cli')
 DB_NAME = defined?(TEST_MODE) ? nil : "#{ENV['HOME']}/.timetrap.db"
+# connect to database.  This will create one if it doesn't exist
 DB = Sequel.sqlite DB_NAME
-
+require File.join(File.dirname(__FILE__), 'timetrap', 'models')
+Dir["#{File.dirname(__FILE__)}/timetrap/formatters/*.rb"].each do |path|
+  require path
+end
 module Timetrap
   extend self
 
-  module CLI
-    attr_accessor :args
-    extend self
-
-    USAGE = <<-EOF
-
-Timetrap - Simple Time Tracking
-
-Usage: #{File.basename $0} COMMAND [OPTIONS] [ARGS...]
-
-where COMMAND is one of:
-  * alter - alter an entry's note, start, or end time. Defaults to the active entry
-    usage: t alter [--id ID] [--start TIME] [--end TIME] [NOTES]
-    -i, --id <id:i>           Alter entry with id <id> instead of the running entry
-    -s, --start <time:qs>     Change the start time to <time>
-    -e, --end <time:qs>       Change the end time to <time>
-  * backend - open an sqlite shell to the database
-    usage: t backend
-  * display - display the current timesheet
-    usage: t display [--ids] [TIMESHEET]
-    -v, --ids                 Print database ids (for use with alter)
-  * format - export a sheet to csv format
-    NOT IMPLEMENTED
-  * in - start the timer for the current timesheet
-    usage: t in [--at TIME] [NOTES]
-    -a, --at <time:qs>        Use this time instead of now
-  * kill - delete a timesheet
-    usage: t kill [--id ID] [TIMESHEET]
-    -i, --id <id:i>           Alter entry with id <id> instead of the running entry
-  * list - show the available timesheets
-    usage: t list
-  * now - show the status of the current timesheet
-    usage: t now
-  * out - stop the timer for the current timesheet
-    usage: t out [--at TIME]
-    -a, --at <time:qs>        Use this time instead of now
-  * running - show all running timesheets
-    NOT IMPLEMENTED
-  * switch - switch to a new timesheet
-    usage: t switch TIMESHEET
-
-    OTHER OPTIONS
-    -h, --help     Display this help
-    EOF
-
-    def parse arguments
-      args.parse arguments
-    end
-
-    def invoke
-      args['-h'] ? say(USAGE) : invoke_command_if_valid
-    end
-
-    def commands
-      Timetrap::CLI::USAGE.scan(/\* \w+/).map{|s| s.gsub(/\* /, '')}
-    end
-
-    def invoke_command_if_valid
-      command = args.unused.shift
-      case (valid = commands.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
-      entry = args['-i'] ? Entry[args['-i']] : Timetrap.active_entry
-      say "can't find entry" && return unless entry
-      entry.update :start => args['-s'] if args['-s'] =~ /.+/
-      entry.update :end => args['-e'] if args['-e'] =~ /.+/
-      entry.update :note => unused_args if unused_args =~ /.+/
-    end
-
-    def backend
-      exec "sqlite3 #{DB_NAME}"
-    end
-
-    def in
-      Timetrap.start unused_args, args['-a']
-    end
-
-    def out
-      Timetrap.stop args['-a']
-    end
-
-    def kill
-      if e = Entry[args['-i']]
-        out = "are you sure you want to delete entry #{e.id}? "
-        out << "(#{e.note}) " if e.note.to_s =~ /.+/
-        print out
-        if $stdin.gets =~ /\Aye?s?\Z/i
-          e.destroy
-          say "it's dead"
-        else
-          say "will not kill"
-        end
-      elsif (sheets = Entry.map{|e| e.sheet }.uniq).include?(sheet = unused_args)
-        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 sheet
-          say "killed #{victims} entries"
-        else
-          say "will not kill"
-        end
-      else
-        victim = args['-i'] ? args['-i'].to_s.inspect : sheet.inspect
-        say "can't find #{victim} to kill", 'sheets:', *sheets
-      end
-    end
-
-    def display
-      sheet = sheet_name_from_string(unused_args)
-      sheet = (sheet =~ /.+/ ? sheet : Timetrap.current_sheet)
-      say "Timesheet: #{sheet}"
-      id_heading = args['-v'] ? 'Id' : '  '
-      say "#{id_heading}  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 "%-4s%16s%11s -%9s%10s    %s" % [
-          (args['-v'] ? e.id : ''),
-          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 "%52s" % 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
-
-    def running
-      say "Sorry not implemented yet :-("
-    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
-
-    def unused_args
-      args.unused.join(' ')
-    end
-
-    public
-    def say *something
-      puts *something
-    end
-  end
-
   def current_sheet= sheet
     m = Meta.find_or_create(:key => 'current_sheet')
     m.value = sheet
@@ -306,45 +64,16 @@ where COMMAND is one of:
     Entry.filter(:sheet => sheet).destroy
   end
 
+  def format format_klass, entries
+    format_klass.new(entries).output
+  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)
     #{CLI::USAGE}
   EOF

data/spec/timetrap_spec.rb

@@ -5,7 +5,7 @@ require 'spec'
 describe Timetrap do
   def create_entry atts = {}
     Timetrap::Entry.create({
-      :sheet => 's1',
+      :sheet => 'default',
       :start => Time.now,
       :end => Time.now,
       :note => 'note'}.merge(atts))
@@ -136,8 +136,42 @@ Id  Day                Start      End        Duration   Notes
       end
 
       describe "format" do
-        it "should export a sheet to a csv format" do
-          pending
+        describe 'ical' do
+          before do
+            create_entry(:start => '2008-10-03 12:00:00', :end => '2008-10-03 14:00:00')
+            create_entry(:start => '2008-10-05 12:00:00', :end => '2008-10-05 14:00:00')
+          end
+
+          it "should filter events by the passed dates" do
+            invoke 'format ical --start 2008-10-03 --end 2008-10-03'
+            $stdout.string.scan(/BEGIN:VEVENT/).should have(1).item
+          end
+
+          it "should not filter events by date when none are passed" do
+            invoke 'format ical'
+            $stdout.string.scan(/BEGIN:VEVENT/).should have(2).item
+          end
+
+          it "should export a sheet to an ical format" do
+            invoke 'format ical --start 2008-10-03 --end 2008-10-03'
+            desired = <<-EOF
+BEGIN:VCALENDAR
+VERSION:2.0
+CALSCALE:GREGORIAN
+METHOD:PUBLISH
+PRODID:iCalendar-Ruby
+BEGIN:VEVENT
+SEQUENCE:0
+DTEND:20081003T140000
+SUMMARY:note
+DTSTART:20081003T120000
+END:VEVENT
+END:VCALENDAR
+            EOF
+            desired.each_line do |line|
+              $stdout.string.should =~ /#{line.chomp}/
+            end
+          end
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: samg-timetrap
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Sam Goldstein
@@ -71,12 +71,18 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- README.md
 - LICENSE.txt
 - Rakefile
-- lib/timetrap.rb
+- README.md
+- bin/dev_t
 - bin/t
+- lib/timetrap
+- lib/timetrap.rb
 - spec/timetrap_spec.rb
+- lib/timetrap/cli.rb
+- lib/timetrap/formatters
+- lib/timetrap/helpers.rb
+- lib/timetrap/models.rb
 has_rdoc: true
 homepage: http://github.com/samg/timetrap/tree/master
 post_install_message: