timelog 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+dev

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in timelog.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sune Kibsgaard Pedersen
+
+MIT License
+
+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,29 @@
+# Timelog
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'timelog'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install timelog
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/timelog

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'timelog'
+
+debug = ENV['TIMELOG_DEBUG'] || ENV['timelog_debug']
+config = ENV['TIMELOG_CONFIG'] || ENV['timelog_config'] || "#{Dir.home}/.timelog.rb"
+
+begin
+  Timelog::Book.open(config) do
+    puts execute ARGV
+  end
+rescue Timelog::Error => e
+  abort e.message
+rescue e
+  if debug
+    raise e
+  else
+    abort "an unexpected error occurred"
+  end
+end

data/lib/timelog.rb

@@ -0,0 +1,41 @@
+require 'active_support/all'
+require 'active_model'
+require 'timelog/version'
+require 'timelog/database'
+require 'timelog/book'
+require 'timelog/configuration'
+require 'timelog/entry'
+require 'timelog/command'
+
+module Timelog
+  class Error < StandardError
+    def initialize(msg = "unknown timelog error occurred")
+      super(msg)
+    end
+  end
+
+  def self.create_error(name, default_message)
+    c = Class.new(Error) do |msg|
+      define_method :initialize do |msg = default_message|
+        super(msg)
+      end
+    end
+    Kernel.const_set name.camelcase, c
+  end
+
+  create_error 'invalid_argument_error', 'invalid arguments'
+  create_error 'invalid_command_error', 'invalid command'
+  create_error 'invalid_entry', 'invalid entry'
+  create_error 'invalid_query_error', 'invalid query'
+  create_error 'entry_started_error', 'entry already started'
+  create_error 'entry_paused_error', 'entry already paused'
+  create_error 'entry_not_active_error', 'entry not active'
+  create_error 'entry_not_paused_error', 'entry is not paused'
+  create_error 'entry_not_started_error', 'entry is not started'
+  create_error 'client_exists_error', 'client already exists'
+  create_error 'client_not_found_error', 'client was not found'
+  create_error 'missing_client_name_error', 'missing client name'
+  create_error 'project_exists_error', 'project already exists'
+  create_error 'project_not_found_error', 'project was not found'
+  create_error 'missing_project_name_error', 'missing project name'
+end

data/lib/timelog/book.rb

@@ -0,0 +1,91 @@
+require 'timelog/book/entries'
+require 'timelog/book/clients'
+require 'timelog/book/projects'
+
+module Timelog
+  class Book
+    attr_reader :configuration, :database
+    
+    # initialize a book
+    #
+    # using a configuration object.
+    # have a look at the .open method for
+    # initializing a book from a configuration file
+    def initialize(configuration)
+      @configuration = configuration
+      @database = Database.new(@configuration)
+      @entries = Entries.new(self)
+      @clients = Clients.new(self)
+      @projects = Projects.new(self)
+    end
+
+    # execute a command
+    #
+    # this finds and executes a command given from a string
+    # or an array of arguments
+    def execute(arguments)
+      arguments = arguments.split if arguments.is_a? String
+      # we have arguments, so try to find the command
+      if arguments.size > 0
+        name = ""
+        # add one argument at a time, until (or never) a command matches
+        command = while(argument = arguments.shift)
+          name += " #{argument}"
+          if obj = Command.get(name.strip, self, arguments)
+            break obj
+          end
+        end
+      # no arguments, use generic command
+      else
+        command = Command.new(self)
+      end
+      raise InvalidCommandError unless command
+
+      # looking for command help? no? then execute!
+      arguments.first.try(:downcase) == "help" ? command.help : command.execute
+    end
+
+    # trigger an event
+    def trigger(group, event, *args)
+      case group
+      when :before
+        @configuration.callbacks[group][event].each {|block| instance_exec(*args, &block)} if @configuration.callbacks[group][event]
+      when :after
+        @configuration.callbacks[group][event].each {|block| instance_exec(*args, &block)} if @configuration.callbacks[group][event]
+      end
+    end
+
+    # get the entries controller
+    #
+    # use this for manipulate entries in the book
+    # if a block is given, it will be evalulated in the
+    # controllers context
+    def entries(&block)
+      @entries.instance_eval(&block) if block_given?
+      @entries
+    end
+
+    def clients(&block)
+      @clients.instance_eval(&block) if block_given?
+      @clients
+    end
+
+    def projects(&block)
+      @projects.instance_eval(&block) if block_given?
+      @projects
+    end
+
+    class << self    
+      # open an existing book
+      #
+      # using a configuration file and an
+      # optional block which will be evaluated
+      # in the book instance
+      def open(file, &block)
+        book = Book.new(Configuration.open(file))
+        book.instance_eval(&block) if block_given?
+        book
+      end
+    end
+  end
+end

data/lib/timelog/book/clients.rb

@@ -0,0 +1,29 @@
+module Timelog
+  class Book
+    class Clients
+      def initialize(book)
+        @book = book
+      end
+
+      def add(name, shortcut = nil)
+        raise ClientExistsError if exists? name or (shortcut and exists? shortcut)
+        @book.database.execute("insert into clients (name, shortcut) values(?, ?)", [name, shortcut])
+        @book.database.first_value("select id from clients order by id desc limit 1")
+      end
+
+      def exists?(client)
+        @book.database.first_value("select id from clients where id = ? or name = ? or shortcut = ?", [client, client, client])
+      end
+
+      def name(client)
+        raise ClientNotFoundError unless exists? client
+        @book.database.first_value("select name from clients where id = ? or name = ? or shortcut = ?", [client, client, client])
+      end
+
+      def id(client)
+        raise ClientNotFoundError unless exists? client
+        @book.database.first_value("select id from clients where id = ? or name = ? or shortcut = ?", [client, client, client])
+      end
+    end
+  end
+end

data/lib/timelog/book/entries.rb

@@ -0,0 +1,151 @@
+module Timelog
+  class Book
+    class Entries
+      QUERY_REGEX = /\A\d+|all|archived|non\-archived|active|today\Z/
+
+      def initialize(book)
+        @book = book
+      end
+
+      # pauses an entry
+      def pause(entry, options = {})
+        raise EntryNotActiveError unless entry.active?
+        raise EntryPausedError if entry.paused?
+        raise EntryNotStarted unless entry.started?
+        @book.trigger :before, :pause, entry
+        entry.pause options[:at]
+        write entry
+        @book.trigger :after, :pause, entry
+      end
+
+      # resumes an entry
+      def resume(entry, options = {})
+        raise EntryNotActiveError unless entry.active?
+        raise EntryNotPausedError unless entry.paused?
+        @book.trigger :before, :resume, entry
+        entry.resume options[:at]
+        write entry
+        @book.trigger :after, :resume, entry
+      end
+
+      # starts an entry
+      def start(entry, options = {})
+        raise EntryStartedError if entry.started?
+        @book.trigger :before, :start, entry
+        entry.started = options[:at] || Time.now
+        write entry
+        @book.trigger :after, :start, entry
+      end
+
+      # ends the entry
+      def stop(entry, options = {})
+        raise EntryNotStartedError unless entry.started?
+        @book.trigger :before, :stop, entry
+        entry.resume(options[:at] || Time.now) if entry.paused?
+        entry.stopped = options[:at] || Time.now
+        write entry
+        @book.trigger :after, :stop, entry
+      end
+
+      # archives the entry
+      def archive(entry, options = {})
+        @book.trigger :before, :archive, entry
+        entry.archived = true
+        write entry
+        @book.trigger :after, :archive, entry
+      end
+
+      # get the active or a new entry
+      #
+      # this can be an already started entry
+      # or a fresh nonstarted entry if an ongoing
+      # entry was not found
+      def active_or_new
+        active || Entry.new
+      end
+
+      # get the active entry
+      #
+      # returns the currently active entry
+      # or nil if none was found
+      def active
+        where("active").first
+      end
+
+      # find entries from query
+      #
+      # get a list of entries, based on the query provided
+      def where(query)
+        raise InvalidQueryError if query !~ QUERY_REGEX    
+        bind = []
+        where = case query.to_s
+        when /\A\d+\Z/
+          bind << query
+          "where id = ?"
+        when "all" then ""
+        when "active" then "where stopped is null"
+        when "archived" then "where archived = 1"
+        when "non-archived" then "where archived = 0"
+        when "today"
+          bind += [Date.today.to_time.to_i, Date.today.to_time.to_i + 24 * 60 * 60]
+          "where started > ? and started < ?"
+        end
+        read(@book.database.first_column("select id from entries #{where} order by id", *bind))
+      end
+
+      # get entries from ids
+      #
+      # fetches and loads all entries with the given ids
+      # returns an array with entries sorted by id desc
+      def read(id)
+        id = [id] unless id.is_a? Array
+        @book.database.execute("select * from entries where id in (#{id.compact.map {"?"}.join(", ")}) order by id", id.compact).map do |row|
+          entry = Entry.new
+          entry.id = row[0]
+          entry.client = row[1]
+          entry.project = row[2]
+          entry.description = row[3]
+          entry.started = Time.at(row[4]) if row[4]
+          entry.stopped = Time.at(row[5]) if row[5]
+          if row[6] and pauses = Marshal.load(row[6])
+            pauses.each {|pause, resume| entry.pause(pause); entry.resume(resume)}
+          end
+          entry.archived = (row[7] == 1) ? true : false
+          entry
+        end
+      end
+
+      # write a single entry to book
+      #
+      # persists an entry to the database
+      # automatically sets the id on the entry
+      # if it is a new entry
+      def write(entry)
+        if entry.valid?
+          data = [
+            entry.client,
+            entry.project,
+            entry.description,
+            entry.started.try(:to_i),
+            entry.stopped.try(:to_i),
+            Marshal.dump(entry.pauses),
+            entry.archived ? 1 : 0
+          ]
+          if entry.id
+            @book.database.execute("update entries set
+              client = ?, project = ?, description = ?, 
+              started = ?, stopped = ?, pauses = ?,
+              archived = ? where id = ?", data << entry.id)
+          else
+            @book.database.execute("insert into entries
+              (client, project, description, started, stopped, pauses, archived) 
+              values(?, ?, ?, ?, ?, ?, ?)", data)
+            entry.id = @book.database.first_value("select id from entries order by id desc limit 1")
+          end
+        else
+          raise InvalidEntryError
+        end
+      end
+    end
+  end
+end

data/lib/timelog/book/projects.rb

@@ -0,0 +1,33 @@
+module Timelog
+  class Book
+    class Projects
+      def initialize(book)
+        @book = book
+      end
+
+      def add(client, project, shortcut = nil)
+        raise ProjectExistsError if exists?(client, project) or (shortcut and exists?(client, shortcut))
+        client = @book.clients.exists? client
+        @book.database.execute("insert into projects (client, name, shortcut) values(?, ?, ?)", [client, project, shortcut])
+        @book.database.first_value("select id from projects order by id desc limit 1")
+      end
+
+      def exists?(client, project)
+        raise ClientNotFoundError unless client = @book.clients.exists?(client)
+        @book.database.first_value("select id from projects where client = ? and (id = ? or name = ? or shortcut = ?)", [client, project, project, project])
+      end
+
+      def name(client, project)
+        client = @book.clients.id(client)
+        raise ProjectNotFoundError unless exists? client, project
+        @book.database.first_value("select name from projects where client = ? and (id = ? or name = ? or shortcut = ?)", [client, project, project, project])
+      end
+
+      def id(client, project)
+        client = @book.clients.id(client)
+        raise ProjectNotFoundError unless exists? client, project
+        @book.database.first_value("select id from projects where client = ? and (id = ? or name = ? or shortcut = ?)", [client, project, project, project])
+      end
+    end
+  end
+end

data/lib/timelog/command.rb

@@ -0,0 +1,59 @@
+module Timelog
+  class Command
+    attr_reader :book, :session, :arguments
+    @commands = {}
+
+    def initialize(book, arguments = [])
+      @book = book
+      @session = session
+      @arguments = arguments
+    end
+
+    def execute
+      help
+    end
+
+    def help
+      <<-HELP
+usage: timelog <command> [arguments]
+
+Commands:
+  #{Command.known.join("\n  ")}
+
+See 'timelog <command> help' for more information on a specific command.
+      HELP
+    end
+
+    def time_in_arguments(default = Time.now)
+      if time = @arguments.find {|arg| arg.match /\A([01]?[0-9]|2[0-3])([\:\.]([0-5][0-9])|)\Z/}
+        hour = time.match(/^([01]?[0-9]|2[0-3])/)[0].to_i
+        minute = time.match(/([\:\.]([0-5][0-9]))$/).try(:values_at, 2).try(:first).try(:to_i) || 0
+        @arguments.delete_if {|arg| arg =~ TIME_REGEX}
+        Time.now.change({hour: hour, min: minute, sec: 0})
+      end
+      default
+    end
+
+    class << self
+      def inherited(subclass)
+        register subclass.name.split("::").last.underscore.gsub("_"," "), subclass
+      end
+
+      def register(name, klass)
+        @commands[name] = klass
+      end
+
+      def get(name, book, arguments = [])
+        klass = @commands[name]
+        klass.new(book, arguments) if klass
+      end
+
+      def known
+        @commands.keys
+      end
+    end
+  end
+end
+
+# register all commands
+Dir[File.dirname(__FILE__) + '/command/*.rb'].each {|file| require file }

data/lib/timelog/command/active.rb

@@ -0,0 +1,20 @@
+module Timelog
+  class Command
+    class Active < Command
+      def execute
+        if entry = book.entries.active
+          client = (entry.client and book.clients.exists?(entry.client)) ? book.clients.name(entry.client) : nil
+          project = (client and entry.project and book.projects.exists?(client, entry.project)) ? book.projects.name(client, entry.project) : nil
+          description = "%s%s" % [client || "n/a", project ? ": #{project}" : ""]
+          "%s - %02d:%02d:%02d#{" (paused)" if entry.paused?}" % ([description] + entry.active_time.values)
+        else
+          "no active entry"
+        end
+      end
+
+      def help
+        "usage: timelog active"
+      end
+    end
+  end
+end

data/lib/timelog/command/archive.rb

@@ -0,0 +1,22 @@
+module Timelog
+  class Command
+    class Archive < Command
+      def execute
+        entries = book.entries.where(arguments.first || "non-archived")
+        entries.delete_if {|e| not e.stopped? or e.archived}
+        if entries.size == 0
+          "no entries found for archiving"
+        else
+          entries.each do |e|
+            book.entries.archive e
+          end
+          "#{entries.length} #{entries.length == 1 ? "entry" : "entries"} archived"
+        end
+      end
+
+      def help
+        "usage: timelog archive [<query>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/client_add.rb

@@ -0,0 +1,17 @@
+module Timelog
+  class Command
+    class ClientAdd < Command
+      def execute
+        raise InvalidArgumentError if arguments.size > 2
+        raise MissingClientNameError unless name = arguments.shift
+
+        book.clients.add name, arguments.shift
+        "client #{name} added"
+      end
+
+      def help
+        "usage: timelog client add <name> [<shortcut>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/help.rb

@@ -0,0 +1,6 @@
+module Timelog
+  class Command
+    # just to make sure the the global help is shown if help is put as an command
+    class Help < Command; end
+  end
+end

data/lib/timelog/command/list.rb

@@ -0,0 +1,64 @@
+module Timelog
+  class Command
+    class List < Command
+      def execute
+        table = book.entries.where(arguments.first || "non-archived").map do |e|
+          {
+            id: e.id,
+            client: e.client ? book.clients.name(e.client) : "",
+            project: e.project ? book.projects.name(e.client, e.project) : "",
+            description: e.description,
+            started: e.started.try(:strftime, "%Y-%m-%d %H:%M"),
+            stopped: e.stopped.try(:strftime, "%Y-%m-%d %H:%M"),
+            "active time" => "%02d:%02d:%02d" % e.active_time.values,
+            "paused time" => e.paused_seconds > 0 ? "%02d:%02d:%02d" % e.paused_time.values : "",
+            "total time" => "%02d:%02d:%02d" % e.total_time.values,
+            status: e.status
+          }
+        end
+
+        if table.size == 0
+          "no entries found"
+        else
+          sizes = column_sizes_for table
+          width = sizes.values.reduce(:+) + sizes.length * 3 + 1
+
+          separater = ''
+          width.times { separater << '-' }
+
+          lines = [separater]
+          lines << "|" + sizes.map do |name, length|
+            " %-#{length}s " % name
+          end.join("|") + "|"
+          lines << separater
+
+          table.each do |row|
+            line = []
+            row.each do |key, value|
+              line << " %-#{sizes[key]}s " % value
+            end
+            lines << "|" + line.join("|") + "|"
+          end
+          lines << separater
+
+          lines.join("\n")
+        end
+      end
+
+      def help
+        "usage: timelog list [<query>]"
+      end
+
+      def column_sizes_for(table)
+        columns = {}
+        table.each do |row|
+          row.each do |key, value|
+            columns[key] ||= key.size
+            columns[key] = value.to_s.size if value and value.to_s.size > columns[key]
+          end
+        end
+        columns
+      end
+    end
+  end
+end

data/lib/timelog/command/pause.rb

@@ -0,0 +1,15 @@
+module Timelog
+  class Command
+    class Pause < Command
+      def execute
+        entry = book.entries.active_or_new
+        book.entries.pause entry, at: time_in_arguments
+        "entry paused"
+      end
+
+      def help
+        "usage: timelog pause [<time>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/project_add.rb

@@ -0,0 +1,18 @@
+module Timelog
+  class Command
+    class ProjectAdd < Command
+      def execute
+        raise InvalidArgumentError if arguments.size > 3
+        raise MissingClientNameError unless client = arguments.shift
+        raise MissingProjectNameError unless name = arguments.shift
+
+        book.projects.add client, name, arguments.shift
+        "project #{name} added"
+      end
+
+      def help
+        "usage: timelog project add <client> <name> [<shortcut>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/resume.rb

@@ -0,0 +1,15 @@
+module Timelog
+  class Command
+    class Resume < Command
+      def execute
+        entry = book.entries.active_or_new
+        book.entries.resume entry, at: time_in_arguments
+        "entry resumed"
+      end
+
+      def help
+        "usage: timelog resume [<time>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/start.rb

@@ -0,0 +1,27 @@
+module Timelog
+  class Command
+    class Start < Command
+      def execute
+        time = time_in_arguments
+        raise InvalidArgumentError if arguments.size > 2
+
+        client = arguments.shift
+        project = arguments.shift
+
+        client = book.clients.id(client) unless client.nil?
+        project = book.projects.id(client, project) unless project.nil?
+
+        entry = book.entries.active_or_new
+        entry.client = client
+        entry.project = project
+
+        book.entries.start entry, at: time
+        "entry started"
+      end
+
+      def help
+        "usage: timelog start [<client>] [<project>] [<time>]"
+      end
+    end
+  end
+end

data/lib/timelog/command/stop.rb

@@ -0,0 +1,19 @@
+module Timelog
+  class Command
+    class Stop < Command
+      def execute
+        time = time_in_arguments
+
+        entry = book.entries.active_or_new
+        entry.description = arguments.join(" ")
+
+        book.entries.stop entry, at: time
+        "entry stopped"
+      end
+
+      def help
+        "usage: timelog stop [<description>] [<time>]"
+      end
+    end
+  end
+end

data/lib/timelog/configuration.rb

@@ -0,0 +1,36 @@
+module Timelog
+  class Configuration
+    attr_accessor :database, :callbacks
+
+    def initialize
+      # defaults
+      @database = "#{Dir.home}/.timelog.db"
+      @callbacks = {before: {}, after: {}}
+    end
+
+    def set(name, value)
+      send("#{name}=", value)
+    end
+
+    def before(event, &block)
+      @callbacks[:before][event.to_sym] ||= []
+      @callbacks[:before][event.to_sym] << block if block_given?
+      @callbacks[:before][event.to_sym]
+    end
+
+    def after(event, &block)
+      @callbacks[:after][event.to_sym] ||= []
+      @callbacks[:after][event.to_sym] << block if block_given?
+      @callbacks[:after][event.to_sym]
+    end
+
+    class << self
+      def open(file = nil, &block)
+        instance = self.new
+        instance.instance_eval(File.read(file), file) if file and File.exists?(file)
+        instance.instance_eval(&block) if block_given?
+        instance
+      end
+    end
+  end
+end

data/lib/timelog/database.rb

@@ -0,0 +1,55 @@
+require 'sqlite3'
+
+module Timelog
+  class Database
+    def initialize(configuration)
+      @configuration = configuration
+      @database = SQLite3::Database.new @configuration.database
+      update_to_latest_version!
+    end
+
+    def execute(sql, bind_vars = [], *args, &block)
+      @database.execute(sql, bind_vars, *args, &block)
+    end
+
+    def first_row(sql, *bind_vars)
+      @database.get_first_row(sql, *bind_vars)
+    end
+
+    def first_value(sql, *bind_vars)
+      @database.get_first_value(sql, *bind_vars)
+    end
+
+    def first_column(sql, *bind_vars)
+      @database.execute(sql, *bind_vars).map {|row| row.first}
+    end
+
+    private
+
+    def update_to_latest_version!
+      # create version table (if not already exists)
+      @database.execute "create table if not exists version (number int)"
+
+      # get current version
+      current = @database.get_first_value("select number from version")
+      unless current
+        @database.execute "insert into version values(0)" 
+        current = 0
+      end
+
+      versions = {
+        1 => "create table entries (id integer primary key, client integer, project integer, description text, started integer, stopped integer)",
+        2 => "alter table entries add column pauses text",
+        3 => "alter table entries add column archived integer not null default 0",
+        4 => "create table clients (id integer primary key, name text not null unique, shortcut text unique)",
+        5 => "create table projects (id integer primary key, client integer not null, name text not null, shortcut text)"
+      }
+
+      # run version migrations
+      versions.each {|version, query| @database.execute(query) if current < version }
+
+      # update version
+      @database.execute("update version set number = ?", versions.keys.last)
+    end
+  end
+end

data/lib/timelog/entry.rb

@@ -0,0 +1,100 @@
+module Timelog
+  class Entry
+    include ActiveModel::Validations
+    
+    attr_accessor :id, :client, :project, :description
+    attr_reader :started, :stopped, :pauses, :archived
+
+    alias :archived? :archived
+
+    def initialize
+      @pauses = {}
+      @archived = false
+    end
+
+    def started=(at)
+      @started = at
+    end
+
+    def stopped=(at)
+      resume if paused?
+      @stopped = at
+    end
+
+    def started?
+      @started
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    def pause(at = Time.now)
+      raise EntryAlreadyPaused if paused?
+      @pauses[at] = nil
+    end
+
+    def resume(at = Time.now)
+      raise EntryNotPaused unless paused?
+      @pauses[@pauses.keys.last] = at
+    end
+
+    def paused?
+      @pauses.length > 0 and @pauses.values.last.nil?
+    end
+
+    def date
+      started.try(:to_date)
+    end
+
+    def active_seconds
+      total_seconds - paused_seconds
+    end
+
+    def paused_seconds
+      pauses.inject(0) do |seconds, pause|
+        seconds + ((pause[1] || Time.now) - pause[0])
+      end.to_i
+    end
+
+    def total_seconds
+      return 0 unless started?
+      ((stopped || Time.now) - started).round
+    end
+
+    def active_time
+      parse_seconds(active_seconds)
+    end
+
+    def paused_time
+      parse_seconds(paused_seconds)
+    end
+
+    def total_time
+      parse_seconds(total_seconds)
+    end
+
+    def archived=(value)
+      @archived = value ? true : false
+    end
+
+    def status
+      return "archived" if archived?
+      return "paused" if paused?
+      return "active" if active?
+    end
+
+    def active?
+      !stopped?
+    end
+
+    private
+
+    def parse_seconds(seconds)
+      hours = seconds / 60 / 60
+      minutes = (seconds - hours * 60 * 60) / 60
+      seconds = (seconds - hours * 60 * 60) - (minutes * 60)
+      {hours: hours, minutes: minutes, seconds: seconds}
+    end
+  end
+end

data/lib/timelog/version.rb

@@ -0,0 +1,3 @@
+module Timelog
+  VERSION = "0.0.1"
+end

data/timelog.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/timelog/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sune Kibsgaard Pedersen"]
+  gem.email         = ["sune@kibs.dk"]
+  gem.description   = %q{Time logger}
+  gem.summary       = %q{Time logger}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "timelog"
+  gem.require_paths = ["lib"]
+  gem.version       = Timelog::VERSION
+  gem.add_dependency "sqlite3", "~> 1.3"
+  gem.add_dependency "activesupport", "= 3.2.11"
+  gem.add_dependency "activemodel", "= 3.2.11"
+  gem.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: timelog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sune Kibsgaard Pedersen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Time logger
+email:
+- sune@kibs.dk
+executables:
+- timelog
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/timelog
+- lib/timelog.rb
+- lib/timelog/book.rb
+- lib/timelog/book/clients.rb
+- lib/timelog/book/entries.rb
+- lib/timelog/book/projects.rb
+- lib/timelog/command.rb
+- lib/timelog/command/active.rb
+- lib/timelog/command/archive.rb
+- lib/timelog/command/client_add.rb
+- lib/timelog/command/help.rb
+- lib/timelog/command/list.rb
+- lib/timelog/command/pause.rb
+- lib/timelog/command/project_add.rb
+- lib/timelog/command/resume.rb
+- lib/timelog/command/start.rb
+- lib/timelog/command/stop.rb
+- lib/timelog/configuration.rb
+- lib/timelog/database.rb
+- lib/timelog/entry.rb
+- lib/timelog/version.rb
+- timelog.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Time logger
+test_files: []
+has_rdoc: