timetrap 1.1.1

data/LICENSE.txt

@@ -0,0 +1,23 @@
+http://www.opensource.org/licenses/mit-license.php
+
+The MIT License
+
+Copyright (c) 2009 Sam Goldstein
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,183 @@
+Timetrap
+========
+
+Timetrap is a utility which provides an easy to use command line interface for
+tracking what you spend your time on.  It is a ruby port of Trevor Caira's
+Timebook, a small python utility.  It contains several enhancement over
+Timebook notably the ability to parse natural language time strings.  This
+makes commands such as ``t in --at "30 minutes ago"`` possible.  Timetrap is
+also able to export entries to several formats (e.g. ical, csv) and is designed
+to be easily extended to support additional export formats.
+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.  The ``--at`` flag is able to parse
+natural language times (via Chronic: http://chronic.rubyforge.org/) and will
+understand 'friday 13:00', 'mon 2:35', '4pm', etc. (also true of the ``edit``
+command's ``--start`` and ``--end`` flags.)  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: timetrap
+        Day                Start      End        Duration   Notes
+        Mon Apr 13, 2009   15:46:51 - 17:03:50   1:16:59    improved display functionality
+                           17:25:59 - 17:26:02   0:00:03
+                           18:38:07 - 18:38:52   0:00:45    working on list
+                           22:37:38 - 23:38:43   1:01:05    work on kill
+                                                 2:18:52
+        Tue Apr 14, 2009   00:41:16 - 01:40:19   0:59:03    gem packaging
+                           10:20:00 - 10:48:10   0:28:10    enhance edit
+                                                 1:27:13
+        ---------------------------------------------------------
+        Total                                    3:46:05
+
+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
+--------
+**archives**
+  Archives the selected entries (by moving them to a sheet called ``_[SHEET]``)
+  These entries can be seen by running ``t display _[SHEET]``.
+  usage: ``t archive [--start DATE] [--end DATE] [SHEET]``
+
+**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. If ``all`` is passed as SHEET display all timesheets. Accepts
+  an optional ``--ids`` flag which will include the entries' ids in the output.
+  This is useful when editing an non running entry with ``edit``.
+
+  Display is designed to support a variety of export formats that can be
+  specified by passing the ``--format`` flag.  This currently defaults to
+  text.  iCal and csv output are also supported.
+
+  Display also allows the use of a ``--round`` or ``-r`` flag which will round
+  all times to 15 minute increments. See global options below.
+
+  usage: ``t display [--ids] [--round] [--start DATE] [--end DATE] [--format FMT] [SHEET | all]``
+
+**edit**
+  Inserts a note associated with the an entry in the timesheet, or edits the
+  start or end times.  Defaults to the current time although an ``--id`` flag can
+  be passed with the entry's id (see display.)
+
+  usage: ``t edit [--id ID] [--start TIME] [--end TIME] [NOTES]``
+
+**format**
+  Deprecated
+  Alias for display
+
+**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 edit NOTES``. Accepts an optional --at flag.
+
+  usage: ``t in [--at TIME] [NOTES]``
+
+**kill**
+  Delete a timesheet or an entry.  Entry's are referenced using an ``--id``
+  flag (see display).  Sheets are referenced by name.
+
+  usage: ``t kill [--id ID] [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.
+
+  usage: ``t now``
+
+**out**
+  Stop the timer for the current timesheet. Must be called after in. Accepts an
+  optional --at flag.
+
+  usage: ``t out [--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``
+
+**week**
+  Shortcut for display with start date set to monday of this week
+
+  usage: ``t week [--ids] [--end DATE] [--format FMT] [SHEET | all]``
+
+Global Options
+--------
+
+**rounding**
+  passing a ``--round`` or ``-r`` flag to any command will round entry start
+  and end times to the closest 15 minute increment.  This flag only affects the
+  display commands (e.g. display, list, week, etc.) and is non-destructive.
+  The actual start and end time stored by Timetrap are unaffected.

data/Rakefile

@@ -0,0 +1,60 @@
+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
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = %q{timetrap}
+    s.version = "0.1.2"
+
+    s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+    s.authors = ["Sam Goldstein"]
+    s.date = %q{2009-04-14}
+    s.description = %q{Command line time tracker}
+    s.email = %q{sgrock@gmail.com}
+    s.has_rdoc = true
+    s.homepage = "http://github.com/samg/timetrap/tree/master"
+    s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+    s.require_paths = ["lib"]
+    s.bindir = "bin"
+    s.executables = ['t']
+    s.summary = %q{Command line time tracker}
+    s.add_dependency("sequel", ">= 2.12.0")
+    s.add_dependency("chronic", ">= 0.2.3")
+    s.add_dependency("getopt-declare", ">= 1.28")
+    s.add_dependency("icalendar", ">= 1.1.0")
+
+    if s.respond_to? :specification_version then
+      current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+      s.specification_version = 2
+
+      if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+        s.add_runtime_dependency(%q<mime-types>, [">= 1.15"])
+        s.add_runtime_dependency(%q<diff-lcs>, [">= 1.1.2"])
+      else
+        s.add_dependency(%q<mime-types>, [">= 1.15"])
+        s.add_dependency(%q<diff-lcs>, [">= 1.1.2"])
+      end
+    else
+      s.add_dependency(%q<mime-types>, [">= 1.15"])
+      s.add_dependency(%q<diff-lcs>, [">= 1.1.2"])
+    end
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 1
+:minor: 1

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/bin/t

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+begin
+  require 'timetrap'
+rescue LoadError
+  if File.symlink? __FILE__
+    require File.dirname(File.readlink(__FILE__)) + '/../lib/timetrap'
+  else
+    require File.dirname(__FILE__) + '/../lib/timetrap'
+  end
+end
+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:
+  * archive - move entries to a hidden sheet (by default named '_[SHEET]') so
+      they're out of the way.
+    usage: t archive [--start DATE] [--end DATE] [SHEET]
+    -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
+  * backend - open an sqlite shell to the database
+    usage: t backend
+  * display - display the current timesheet or a specific. Pass `all' as
+      SHEET to display all sheets.
+    usage: t display [--ids] [--start DATE] [--end DATE] [--format FMT] [SHEET | all]
+    -v, --ids                 Print database ids (for use with edit)
+    -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
+    -f, --format <format>     The output format.  Currently supports ical, csv, and
+                                text (default).
+  * edit - alter an entry's note, start, or end time. Defaults to the active entry
+    usage: t edit [--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>
+  * format - deprecated: alias for display
+  * 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
+    usage: t running
+  * switch - switch to a new timesheet
+    usage: t switch TIMESHEET
+  * week - shortcut for display with start date set to monday of this week
+    usage: t week [--ids] [--end DATE] [--format FMT] [SHEET | all]
+
+    OTHER OPTIONS
+    -h, --help     Display this help
+    -r, --round    Round output  to 15 minute start and end times.
+    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
+      set_global_options
+      case (valid = commands.select{|name| name =~ %r|^#{command}|}).size
+      when 0 then say "Invalid command: #{command}"
+      when 1 then send valid[0]
+      else
+        say "Ambiguous command: #{command}" if command
+        say(USAGE)
+      end
+    end
+
+    # currently just sets whether output should be rounded to 15 min intervals
+    def set_global_options
+      Timetrap::Entry.round = true if args['-r']
+    end
+
+    def archive
+      ee = selected_entries
+      out = "Archive #{ee.count} entries? "
+      print out
+      if $stdin.gets =~ /\Aye?s?\Z/i
+        ee.all.each do |e|
+          next unless e.end
+          e.update :sheet => "_#{e.sheet}"
+        end
+      else
+        say "archive aborted!"
+      end
+    end
+
+    def edit
+      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
+      begin
+        fmt_klass = if args['-f']
+          Timetrap::Formatters.const_get("#{args['-f'].classify}")
+        else
+          Timetrap::Formatters::Text
+        end
+      rescue
+        say "Invalid format specified `#{args['-f']}'"
+        return
+      end
+      say Timetrap.format(fmt_klass, selected_entries.order(:start).all)
+    end
+    alias_method :format, :display
+
+
+    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.sheets.map do |sheet|
+        sheet_atts = {:total => 0, :running => 0, :today => 0}
+        Timetrap::Entry.filter(:sheet => sheet).inject(sheet_atts) do |m, e|
+          e_end = e.end_or_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
+      if sheets.empty? then say "No sheets found"; return 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, Timetrap.active_entry.end_or_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 "Running Timesheets:"
+      say Timetrap::Entry.filter(:end => nil).map{|e| "  #{e.sheet}: #{e.note}"}.uniq.sort
+    end
+
+    def week
+      args['-s'] = Date.today.wday == 1 ? Date.today.to_s : Date.parse(Chronic.parse(%q(last monday)).to_s).to_s
+      display
+    end
+
+    private
+
+    def unused_args
+      args.unused.join(' ')
+    end
+
+  end
+end

data/lib/timetrap/formatters/csv.rb

@@ -0,0 +1,19 @@
+module Timetrap
+  module Formatters
+    class Csv
+      attr_reader :output
+
+      def initialize entries
+        @output = entries.inject("start,end,note\n") do |out, e|
+          next(out) unless e.end
+          out << %|"#{e.start.strftime(time_format)}","#{e.end.strftime(time_format)}","#{e.note}"\n|
+        end
+      end
+
+      private
+      def time_format
+        "%Y-%m-%d %H:%M:%S"
+      end
+    end
+  end
+end

data/lib/timetrap/formatters/ical.rb

@@ -0,0 +1,29 @@
+require 'icalendar'
+require 'date'
+module Timetrap
+  module Formatters
+    class Ical
+      include Icalendar
+      def calendar
+        @calendar ||= Calendar.new
+      end
+
+      def output
+        calendar.to_ical
+      end
+
+      def initialize entries
+        entries.each do |e|
+          next unless e.end
+          calendar.event do
+            dtstart DateTime.parse(e.start.to_s)
+            dtend DateTime.parse(e.end.to_s)
+            summary e.note
+            description e.note
+          end
+        end
+        calendar.publish
+      end
+    end
+  end
+end

data/lib/timetrap/formatters/text.rb

@@ -0,0 +1,55 @@
+module Timetrap
+  module Formatters
+    class Text
+      attr_accessor :output
+      include Timetrap::Helpers
+
+      def initialize entries
+        self.output = ''
+        sheets = entries.inject({}) do |h, e|
+          h[e.sheet] ||= []
+          h[e.sheet] << e
+          h
+        end
+        (sheet_names = sheets.keys.sort).each do |sheet|
+          self.output <<  "Timesheet: #{sheet}\n"
+          id_heading = Timetrap::CLI.args['-v'] ? 'Id' : '  '
+          self.output <<  "#{id_heading}  Day                Start      End        Duration   Notes\n"
+          last_start = nil
+          from_current_day = []
+          sheets[sheet].each_with_index do |e, i|
+            from_current_day << e
+            e_end = e.end_or_now
+            self.output <<  "%-4s%16s%11s -%9s%10s    %s\n" % [
+              (Timetrap::CLI.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 = sheets[sheet].map[i+1]
+            if nxt == nil or !same_day?(e.start, nxt.start)
+              self.output <<  "%52s\n" % format_total(from_current_day)
+              from_current_day = []
+            else
+            end
+            last_start = e.start
+          end
+          self.output <<  <<-OUT
+    ---------------------------------------------------------
+          OUT
+          self.output <<  "    Total%43s\n" % format_total(sheets[sheet])
+          self.output <<  "\n" unless sheet == sheet_names.last
+        end
+        if sheets.size > 1
+          self.output <<  <<-OUT
+-------------------------------------------------------------
+          OUT
+          self.output <<  "Grand Total%41s\n" % format_total(sheets.values.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/timetrap/helpers.rb

@@ -0,0 +1,59 @@
+module Timetrap
+  module Helpers
+
+    def selected_entries
+      ee = if (sheet = sheet_name_from_string(unused_args)) == 'all'
+        Timetrap::Entry.filter('sheet not like ? escape "!"', '!_%')
+      elsif sheet =~ /.+/
+        Timetrap::Entry.filter('sheet = ?', sheet)
+      else
+        Timetrap::Entry.filter('sheet = ?', Timetrap.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']
+      ee
+    end
+
+    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_or_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 "all" if string =~ /^\W*all\W*$/
+      return "" unless string =~ /.+/
+      DB[:entries].filter(:sheet.like("#{string}%")).first[:sheet]
+    rescue
+      ""
+    end
+  end
+end