did 0.2.01

data/README.rdoc

@@ -0,0 +1,52 @@
+= DID - timetracking for the non-clairvoyant
+
+Did version 0.2.0
+
+This package contains Did, a command-line utility for quickly
+recording what you last worked on. More than just a tool, Did is also
+a mindset: it brings your awareness to task switches, those notorious
+time sinks.
+
+== Installation
+
+=== Gem installation
+
+Download and install Did with the following
+
+    gem install did
+
+For bash autocompletion of tags, add the following to the end of your
+.bashrc file
+
+    complete -C `which did_autocomplete | tail -n 1` did
+
+== Usage
+
+Tell Did that you've started working.
+   
+    did sit!
+
+Then, when you find yourself changing tasks, tell Did what you were just doing.
+
+    did [tag 1] [tag 2] ...
+
+After a while, you can ask what you did today.
+
+    did what?
+
+Or ask how your time has broken down across your descriptions of tasks.
+
+    did what? tags
+
+
+== Credits
+
+Written by Andrew Paradise in 2011.
+
+
+== Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantibility and fitness for a particular
+purpose.

data/bin/did

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+ALLOW_CREATE = true
+
+require 'did'
+
+action = Did::Action.parse(ARGV)
+action.perform

data/bin/did_autocomplete

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+ALLOW_CREATE = false
+
+require 'did'
+
+exit unless $env.database_file_exist?
+command, partial, prior = ARGV[0..2]
+tags = Did::Tag.find(:all, :conditions => ["label like ?", partial + "%"])
+tags.each do |tag|
+  puts tag.label
+end

data/db/config.yml

@@ -0,0 +1,5 @@
+
+
+test:
+  adapter: sqlite3
+  database: db/test.sq3

data/db/migrations/20110521000254_create_tag_table.rb

@@ -0,0 +1,13 @@
+class CreateTagTable < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :label
+    end
+    add_index :tags, [:label], :unique => true
+  end
+
+  def self.down
+    remove_index :tags, :label
+    drop_table :tags
+  end
+end

data/db/migrations/20110521021941_create_work_tables.rb

@@ -0,0 +1,20 @@
+class CreateWorkTables < ActiveRecord::Migration
+  def self.up
+    create_table :spans do |t|
+      t.timestamp :start_time
+      t.timestamp :end_time
+    end
+
+    create_table :spans_tags, :id => false do |t|
+      t.integer :span_id
+      t.integer :tag_id
+    end
+    add_index :spans_tags, :tag_id
+  end
+
+  def self.down
+    remove_index :spans_tags, :tag_id
+    drop_table :spans_tags
+    drop_table :spans
+  end
+end

data/db/migrations/20110521134514_create_sitting_table.rb

@@ -0,0 +1,14 @@
+class CreateSittingTable < ActiveRecord::Migration
+  def self.up
+    create_table :sittings do |t|
+      t.timestamp :start_time
+      t.timestamp :end_time
+    end
+    add_column :spans, :sitting_id, :integer
+  end
+
+  def self.down
+    remove_column :spans, :sitting_id
+    drop_table :sittings
+  end
+end

data/db/migrations/20110521153703_add_current_flag_to_sitting.rb

@@ -0,0 +1,11 @@
+class AddCurrentFlagToSitting < ActiveRecord::Migration
+  def self.up
+    add_column :sittings, :current, :boolean
+    add_index :sittings, [:current]
+  end
+
+  def self.down
+    remove_index :sittings, [:current]
+    remove_column :sittings, :current
+  end
+end

data/db/migrations/20110521174213_add_sitting_start_end_to_span.rb

@@ -0,0 +1,13 @@
+class AddSittingStartEndToSpan < ActiveRecord::Migration
+  def self.up
+    add_column :spans, :sitting_start, :boolean
+    add_column :spans, :sitting_end, :boolean
+    add_column :sittings, :end_span_id, :integer
+  end
+
+  def self.down
+    remove_column :sittings, :end_span_id
+    remove_column :spans, :sitting_end
+    remove_column :spans, :sitting_start
+  end
+end

data/db/migrations/20110524024714_add_sitting_tags.rb

@@ -0,0 +1,9 @@
+class AddSittingTags < ActiveRecord::Migration
+  def self.up
+    add_column :sittings, :tag_labels, :string
+  end
+
+  def self.down
+    remove_column :sittings, :tag_labels
+  end
+end

data/db/schema.rb

@@ -0,0 +1,45 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20110521174213) do
+
+  create_table "sittings", :force => true do |t|
+    t.datetime "start_time"
+    t.datetime "end_time"
+    t.boolean  "current"
+    t.integer  "end_span_id"
+  end
+
+  add_index "sittings", ["current"], :name => "index_sittings_on_current"
+
+  create_table "spans", :force => true do |t|
+    t.datetime "start_time"
+    t.datetime "end_time"
+    t.integer  "sitting_id"
+    t.boolean  "sitting_start"
+    t.boolean  "sitting_end"
+  end
+
+  create_table "spans_tags", :id => false, :force => true do |t|
+    t.integer "span_id"
+    t.integer "tag_id"
+  end
+
+  add_index "spans_tags", ["tag_id"], :name => "index_spans_tags_on_tag_id"
+
+  create_table "tags", :force => true do |t|
+    t.string "label"
+  end
+
+  add_index "tags", ["label"], :name => "index_tags_on_label", :unique => true
+
+end

data/db/schema.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL);
+CREATE TABLE "sittings" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "start_time" datetime, "end_time" datetime, "current" boolean, "end_span_id" integer);
+CREATE TABLE "spans" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "start_time" datetime, "end_time" datetime, "sitting_id" integer, "sitting_start" boolean, "sitting_end" boolean);
+CREATE TABLE "spans_tags" ("span_id" integer, "tag_id" integer);
+CREATE TABLE "tags" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "label" varchar(255));
+CREATE INDEX "index_sittings_on_current" ON "sittings" ("current");
+CREATE INDEX "index_spans_tags_on_tag_id" ON "spans_tags" ("tag_id");
+CREATE UNIQUE INDEX "index_tags_on_label" ON "tags" ("label");
+CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version");

data/lib/did.rb

@@ -0,0 +1,6 @@
+require 'did/env'
+require 'did/action'
+
+module Did
+  VERSION = "0.2.01"
+end

data/lib/did/action.rb

@@ -0,0 +1,44 @@
+require 'did/action/sit'
+require 'did/action/submit'
+require 'did/action/report'
+
+module Did
+  module Action
+    def self.parse(argv)
+      if argv[0] == "sit!"
+        parse_sit(argv)
+      elsif argv[0] == "what?"
+        parse_report(argv)
+      else
+        parse_submit(argv)
+      end
+    end
+
+    private
+
+    def self.parse_sit(argv)
+      sit = Sit.new
+      sit.start_time = Time.now
+
+      sit
+    end
+
+    def self.parse_submit(argv)
+      submit = Submit.new
+      submit.labels = argv
+      submit.start_time = 2.hours.ago
+      submit.end_time = Time.now
+
+      submit
+    end
+
+    def self.parse_report(argv)
+      report = Report.new
+      
+      report.format = (argv[1] || "timeline").to_sym
+      report.range = Date.today
+
+      report
+    end
+  end
+end

data/lib/did/action/report.rb

@@ -0,0 +1,69 @@
+
+
+module Did
+  module Action
+    class Report
+      attr_accessor :format
+      attr_accessor :range
+
+      def initialize
+      end
+      
+      def perform
+        case @format
+        when :timeline
+          perform_timeline
+        when :tags
+          perform_tags
+        end
+      end
+
+      def perform_timeline
+        timeline_report(Span.find_for_day(@range))
+      end
+
+      def perform_tags
+        tags_report(Span.find_for_day(@range))
+      end
+
+      def timeline_report(spans)
+        spans.each do |span|
+          sitting_char = "|"
+          if span.entire_sitting?
+            sitting_char = "]"
+          elsif span.sitting_start?
+            sitting_char = "\\"
+          elsif span.sitting_end?
+            sitting_char = "/"
+          end
+          
+          puts "#{span.start_time} - #{span.end_time} (#{duration_to_s(span.duration)}): #{sitting_char} #{span.tags.map{|t| t.label}.join(", ")}"
+        end
+      end
+      
+      def tags_report(spans)
+        tag_totals = Hash.new{|hash, key| hash[key] = 0}
+        spans.each do |span|
+          span.tags.each do |tag|
+            tag_totals[tag.label]+= span.duration
+          end
+        end
+        max_length = tag_totals.keys.map(&:length).max
+        tag_totals = tag_totals.sort{|a, b| a[1] <=> b[1]}.reverse
+        tag_totals.each do |tag_label, duration|
+          puts "#{tag_label.ljust(max_length + 3)}  #{duration_to_s(duration)}"
+        end
+      end
+
+      def duration_to_s(duration)
+        total_seconds = duration.floor
+        milliseconds = duration - total_seconds
+        seconds = total_seconds % 60
+        minute_seconds = (total_seconds - seconds) % 3600
+        hour_seconds = total_seconds - seconds - minute_seconds
+        
+        "%03d:%02d:%02d" %  [hour_seconds / 3600, minute_seconds / 60, seconds]
+      end
+    end
+  end
+end

data/lib/did/action/sit.rb

@@ -0,0 +1,20 @@
+require 'did/sitting'
+
+module Did
+  module Action
+    class Sit
+      attr_accessor :start_time
+
+      def perform
+        current_sitting = Sitting.find(:first, :conditions => {:current => true})
+
+        if current_sitting && current_sitting.end_time.nil?
+          current_sitting.update_attributes(:start_time => @start_time)
+        else
+          current_sitting.update_attributes(:current => false) if current_sitting
+          Sitting.create(:start_time => @start_time, :current => true)
+        end
+      end
+    end
+  end
+end

data/lib/did/action/submit.rb

@@ -0,0 +1,74 @@
+require 'did/tag'
+require 'did/span'
+require 'did/sitting'
+
+module Did
+  module Action
+    class Submit
+      attr_accessor :labels
+      attr_accessor :start_time
+      attr_accessor :end_time
+
+      def initialize()
+        @resolved = false
+      end
+
+      def perform
+        tags = labels.map do |label|
+          Tag.find_or_create_by_label(label);
+        end
+        
+        prior_sitting = Sitting.find_current
+        current_sitting = nil
+        sitting_start = true
+        if prior_sitting && prior_sitting.end_time.nil?
+          if prior_sitting.start_time > @start_time
+            @start_time = prior_sitting.start_time
+          end
+          current_sitting = prior_sitting
+          prior_sitting = nil
+        elsif prior_sitting && prior_sitting.end_time > @start_time
+          @start_time = prior_sitting.end_time + 1.second
+          current_sitting = prior_sitting
+          sitting_start = false
+        end
+
+        prior_span = prior_sitting.end_span if prior_sitting
+        if prior_span && prior_span.tags == tags
+          prior_span.update_attributes(:end_time => @end_time)
+          prior_sitting.update_attributes(:end_time => @end_time)
+          return
+        end
+        
+        span = Span.create(:tags => tags, 
+                           :end_time => @end_time, :start_time => @start_time,
+                           :sitting_start => sitting_start, :sitting_end => true)
+
+        # We are about to start a new sitting, so we close out the old.
+        if prior_sitting && current_sitting.nil?
+          prior_sitting.update_attributes(:current => false)
+        end
+
+        if current_sitting
+          # Shift end time of sitting to include new span.
+          current_sitting.end_span.update_attributes(:sitting_end => false) if current_sitting.end_span
+          params = {
+            :end_time => @end_time,
+            :end_span_id => span.id
+          }
+
+          # We are commandeering the last sitting created by a 'sit' action.
+          params[:start_time] = @start_time if current_sitting.end_time.nil?
+          current_sitting.update_attributes(params)
+        end
+        
+        unless current_sitting 
+          current_sitting = Sitting.create(:start_time => @start_time, :end_time => @end_time, 
+                                           :end_span_id => span.id, :current => true)
+        end
+
+        span.update_attributes(:sitting_id => current_sitting.id)
+      end
+    end
+  end
+end

data/lib/did/env.rb

@@ -0,0 +1,80 @@
+require 'active_record'
+require 'pathname'
+require 'sqlite3'
+
+class Env
+  attr_reader :profile_name
+
+  def initialize(profile_name, allow_create = true)
+    @profile_name = profile_name
+    @allow_create = allow_create
+  end
+
+  def allow_create?
+    @allow_create
+  end
+
+  def setup_active_record
+    initialize_home
+    config = {"adapter" => 'sqlite3', "database" => database_path.to_s}
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  def setup_development(environment_name)
+    config = development_database_config(environment_name)
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  def database_file_exist?
+    database_path.exist?
+  end
+
+  def db
+    return nil if !allow_create? && !database_file_exist?
+    @@db ||= SQLite3::Database.new(database_path.to_s)
+  end
+
+  private
+
+  def initialize_home
+    did_home.mkpath
+    database_path.dirname.mkpath
+    if !database_file_exist?
+      puts "initializing DID database: #{database_path}"
+      File.readlines("db/schema.sql").each do |line|
+        db.execute(line)
+      end
+    end
+  end
+
+  def did_home
+    Pathname.new('~').expand_path + ".did"
+  end
+
+  def database_path
+    did_home + profile_name + "did.db"
+  end
+
+  def development_database_config(environment_name)
+    home = File.dirname(__FILE__) + '/../../'
+    database_config_path = home + 'db/config.yml'
+    raise "database configuration file not found at: #{database_config_path}" unless File.exist?(database_config_path)
+    config_all = YAML.load(File.read(database_config_path))
+    config = config_all[environment_name]
+    raise "#{environment_name} environment not configured in #{database_config_path}" unless config
+    if config['adapter'] == 'sqlite3' && config['database'][0] != "/"
+      config['database'] = (home + config['database'])
+    end
+
+    config
+  end
+end
+
+DID_PROFILE = ENV['DID_PROFILE'] || 'default'
+$env = Env.new(DID_PROFILE, defined?(ALLOW_CREATE) ? ALLOW_CREATE : true)
+exit if !$env.allow_create? && !$env.database_file_exist?
+unless defined?(ENVIRONMENT_NAME)
+  $env.setup_active_record
+else
+  $env.setup_development(ENVIRONMENT_NAME)
+end

data/lib/did/sitting.rb

@@ -0,0 +1,10 @@
+
+module Did
+  class Sitting < ActiveRecord::Base
+    belongs_to :end_span, :class_name => "Span"
+
+    def self.find_current
+      find(:first, :conditions => {:current => true})
+    end
+  end
+end

data/lib/did/span.rb

@@ -0,0 +1,24 @@
+
+
+module Did
+  class Span < ActiveRecord::Base
+    has_and_belongs_to_many :tags
+    belongs_to :sitting
+
+    def entire_sitting?
+      sitting_start? && sitting_end?
+    end
+
+    def self.find_for_day(date)
+      Span.find(:all, :conditions => ["end_time >= ? AND start_time <= ?", date, date + 1.day], :order => :start_time)
+    end
+
+    def duration
+      end_time - start_time
+    end
+
+    def include?(tag)
+      tags.include? tag
+    end
+  end
+end

data/lib/did/tag.rb

@@ -0,0 +1,7 @@
+
+
+module Did
+  class Tag < ActiveRecord::Base
+    
+  end
+end

data/tests/all

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+$: << File.dirname(__FILE__) + "/../lib"
+require 'pathname'
+
+def include_directory(dir) 
+  dir.each_entry do |entry|
+    next if entry.to_s=~ /^\./
+    if (dir + entry).directory?
+      include_directory(dir + entry)      
+      next
+    end
+    next unless entry.to_s=~ /^tc_.+\.rb$/
+    
+    load dir + entry
+  end
+end
+
+include_directory(Pathname.new(__FILE__).dirname)

data/tests/helpers.rb

@@ -0,0 +1,37 @@
+
+
+def perform_action(action, params = {})
+  action_class = Did::Action.const_get(action.to_s.camelize)
+  action = action_class.new
+  params.each do |key, value|
+    setter = (key.to_s + "=").to_sym
+    action.send(setter, value)
+  end
+  action.perform
+end
+
+
+def assert_correct_sitting_bounds(spans)
+  prior_sitting_id = nil
+  sitting_index = 0
+  sitting_span_index = 0
+  0.upto(spans.length - 1) do |index|
+    sitting_span_index+= 1
+    span = spans[index]
+    next_span = spans[index + 1]
+    sitting_start = span.sitting_id != prior_sitting_id
+    sitting_end = next_span.nil? || next_span.sitting_id != span.sitting_id
+
+    location = "#{sitting_span_index}th span in #{sitting_index}th sitting"
+    assert_equal(sitting_start, span.sitting_start, "#{location} sitting_start")
+    assert_equal(sitting_end, span.sitting_end, "#{location} sitting_start")
+    assert_equal(span.id, span.sitting.end_span_id, "sitting.end_span of #{sitting_index}th sitting") if sitting_end
+    
+    if prior_sitting_id != span.sitting_id
+      prior_sitting_id = span.sitting_id
+      sitting_span_index = 0
+      sitting_index+= 1
+    end
+  end
+end
+

data/tests/integration/tc_sit_perform.rb

@@ -0,0 +1,146 @@
+$: << File.dirname(__FILE__) + "/../.."
+require 'tests/setup'
+
+require 'did/action/sit'
+require 'did/action/submit'
+
+class TCSitPerform < Test::Unit::TestCase
+
+  def test_first_span_no_prior_sitting
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => [],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+
+    assert_equal(1, spans.length,                               "Should be one span")
+    assert_equal(1, sittings.length,                            "Should be one sitting")
+    assert_equal(true, sittings[0].current?,                    "Should mark sitting as current")
+    assert_equal(spans[0].start_time, sittings[0].start_time,   "Should have matching start_times")
+    assert_equal(spans[0].end_time, sittings[0].end_time,       "Should have matching start_times")
+
+    assert_correct_sitting_bounds(spans)
+  end
+
+  def test_prior_submit_too_old
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+    perform_action(:submit, :labels => ['two'],
+                   :start_time => start_time + 40.minutes,
+                   :end_time   => start_time + 50.minutes)
+
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+
+    assert_equal(2, sittings.length,                            "Should be two sittings")
+    assert_equal(sittings[0], spans[0].sitting,                 "Should match first span to first sitting")
+    assert_equal(sittings[1], spans[1].sitting,                 "Should match second span to second sitting")
+    assert_equal(false, sittings[0].current?,                   "Should mark first sitting as not current")
+    assert_equal(true, sittings[1].current?,                    "Should mark second sitting as current")
+
+    assert_correct_sitting_bounds(spans)
+  end
+
+
+  def test_prior_submit_recent
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+    perform_action(:submit, :labels => ['two'],
+                   :start_time => start_time + 5.minutes,
+                   :end_time   => start_time + 15.minutes)
+
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+
+    assert_equal(1, sittings.length,                            "Should be one sitting")
+    assert_equal(sittings[0], spans[0].sitting,                 "Should match first span to first sitting")
+    assert_equal(sittings[0], spans[1].sitting,                 "Should match second span to first sitting")
+    assert_equal(true, sittings[0].current?,                    "Should mark first sitting as current")
+
+    assert_correct_sitting_bounds(spans)
+  end
+
+  def test_prior_sit_recent
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:sit,
+                   :start_time => start_time)
+    perform_action(:submit, :labels => [],
+                   :start_time => start_time - 5.minutes,
+                   :end_time   => start_time + 5.minutes)
+    
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+
+    assert_equal(1, sittings.length,                            "Should be one sitting")
+    assert_equal(start_time, spans[0].start_time,               "Span should use sit's start time")
+    assert_equal(start_time + 5.minutes, sittings[0].end_time,  "Sitting should use span's end time")
+    assert_equal(true, sittings[0].current?,                    "Should mark sitting as current")
+
+    assert_correct_sitting_bounds(spans)
+  end  
+
+
+  def test_prior_sit_too_old
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:sit,
+                   :start_time => start_time)
+    perform_action(:submit, :labels => [],
+                   :start_time => start_time + 25.minutes,
+                   :end_time   => start_time + 35.minutes)
+    
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+
+    assert_equal(1, sittings.length,                            "Should be one sitting")
+    assert_equal(start_time + 25.minutes, spans[0].start_time,  "Span should use span's start time")
+    assert_equal(start_time + 35.minutes, sittings[0].end_time, "Sitting should use span's end time")
+    assert_equal(true, sittings[0].current?,                    "Should mark sitting as current")
+
+    assert_correct_sitting_bounds(spans)
+  end  
+
+  def test_sit_after_submit
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => [],
+                   :start_time => start_time,
+                   :end_time   => start_time + 10.minutes)
+    perform_action(:sit,
+                   :start_time => start_time + 15.minutes)
+    perform_action(:submit, :labels => [],
+                   :start_time => start_time + 8.minutes,
+                   :end_time   => start_time + 18.minutes)
+
+    spans = Did::Span.find(:all, :order => :start_time)
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+    
+    assert_equal(2, sittings.length,                            "Should be two sittings")
+    assert_equal(start_time + 15.minutes, sittings[1].start_time)
+    assert_equal(start_time + 18.minutes, sittings[1].end_time)
+    
+    assert_correct_sitting_bounds(spans)
+  end
+
+  def test_double_sit
+    start_time = Time.local(2011,05,21, 10,00,00) 
+    perform_action(:sit,
+                   :start_time => start_time)
+    perform_action(:sit,
+                   :start_time => start_time + 1.minute)
+
+    sittings = Did::Sitting.find(:all, :order => :start_time)
+    
+    assert_equal(1, sittings.length,                            "Should be one sitting")
+  end
+
+
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+end

data/tests/integration/tc_tags.rb

@@ -0,0 +1,45 @@
+$: << File.dirname(__FILE__) + "/../.."
+require 'tests/setup'
+
+class TCTags < Test::Unit::TestCase
+
+  def test_create_tags
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+
+    tags = Did::Tag.find(:all)
+    assert_equal(1, tags.length,   "Should create a tag")
+  end
+
+  def test_no_duplicate_tags
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time + 11, 
+                   :end_time   => start_time + 21.minutes)
+
+    tags = Did::Tag.find(:all)
+    assert_equal(1, tags.length,   "Should create only one tag")
+  end
+  
+  def test_contiguous_identical_tags
+    start_time = Time.local(2011,05,21, 10,00,00)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time, 
+                   :end_time   => start_time + 10.minutes)
+    perform_action(:submit, :labels => ['one'],
+                   :start_time => start_time + 20, 
+                   :end_time   => start_time + 30.minutes)
+
+    spans = Did::Span.find(:all, :order => :start_time)
+    assert_equal(1, spans.length,   "Should reuse first span")
+  end
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+end

data/tests/profile.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+$: << File.realpath(File.dirname(__FILE__) + "/../lib")
+$: << File.dirname(__FILE__) + "/.."
+ENVIRONMENT_NAME = 'test'
+
+require 'did'
+require 'tests/helpers'
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+
+
+WORD_COUNT = 50
+SITTING_COUNT = 10
+SPAN_COUNT_PER_SITTING = 10
+
+
+dictionary_file = File.dirname(__FILE__) + "/../notes/dictionary_short"
+words = `cat #{dictionary_file} | head -n #{WORD_COUNT}`.split("\n")
+word_index = 0
+
+time = Time.local(2001,01,01, 12,01,01)
+times = []
+
+0.upto(SITTING_COUNT) do
+  times << time += 8.minutes
+  0.upto(SPAN_COUNT_PER_SITTING) do
+    times << time += 8.minutes
+  end
+end
+
+DatabaseCleaner.clean
+require 'perftools'
+start_time = Time.now
+puts "starting profile: #{times.length} actions"
+PerfTools::CpuProfiler.start("profile/many_spans") do
+  times.each_with_index do |time, index|
+    if (index % (SPAN_COUNT_PER_SITTING + 1) == 0)
+      action = Did::Action.parse(["sit"])
+      action.perform
+    else
+      action = Did::Action.parse([words[index % WORD_COUNT]])
+      action.perform
+    end
+  end
+end
+end_time = Time.now
+
+puts "#{times.length} actions (#{WORD_COUNT} words, #{SPAN_COUNT_PER_SITTING}:1 span:sit) - " + 
+  "#{end_time - start_time} #{(end_time - start_time) / times.length} per action"

data/tests/setup.rb

@@ -0,0 +1,12 @@
+$: << File.realpath(File.dirname(__FILE__) + "/../lib")
+ENVIRONMENT_NAME = 'test'
+
+require 'test/unit'
+require 'did/env'
+
+require 'tests/helpers'
+
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+DatabaseCleaner.clean
+

data/tests/unit/tc_span_find_for_day.rb

@@ -0,0 +1,34 @@
+$: << File.dirname(__FILE__) + "/../.."
+require 'tests/setup'
+
+require 'did/span'
+
+class TCSpanFindForDay < Test::Unit::TestCase
+  
+  def test_date_range
+    today = Date.civil(2011,10,05)
+    
+    span_1 = Did::Span.create(:start_time => today - 1.hour,
+                              :end_time   => today - 50.minutes)
+    span_2 = Did::Span.create(:start_time => today - 5.minutes,
+                              :end_time   => today + 5.minutes)
+    span_3 = Did::Span.create(:start_time => today + 15.minutes, 
+                              :end_time   => today + 25.minutes)
+    span_4 = Did::Span.create(:start_time => today + 23.hours + 55.minutes,
+                              :end_time   => today + 1.day + 5.minutes)
+    span_5 = Did::Span.create(:start_time => today + 1.day + 10.minutes, 
+                              :end_time   => today + 1.day + 20.minutes)
+    
+    spans = Did::Span.find_for_day(today)
+
+    assert_equal(span_2, spans[0])
+    assert_equal(span_3, spans[1])
+    assert_equal(span_4, spans[2])
+    assert_equal(3, spans.length)
+  end
+
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: did
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.01
+platform: ruby
+authors: 
+- Andrew Paradise
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id002
+description: |
+  DID is a time tracking system where you tell it what you did, not what
+  you plan to do. 
+
+email: adparadise@gmail.com
+executables: 
+- did
+- did_autocomplete
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- db/migrations/20110524024714_add_sitting_tags.rb
+- db/migrations/20110521021941_create_work_tables.rb
+- db/migrations/20110521000254_create_tag_table.rb
+- db/migrations/20110521174213_add_sitting_start_end_to_span.rb
+- db/migrations/20110521134514_create_sitting_table.rb
+- db/migrations/20110521153703_add_current_flag_to_sitting.rb
+- db/config.yml
+- db/schema.rb
+- db/schema.sql
+- lib/did/env.rb
+- lib/did/span.rb
+- lib/did/action/report.rb
+- lib/did/action/submit.rb
+- lib/did/action/sit.rb
+- lib/did/action.rb
+- lib/did/tag.rb
+- lib/did/sitting.rb
+- lib/did.rb
+- tests/integration/tc_sit_perform.rb
+- tests/integration/tc_tags.rb
+- tests/setup.rb
+- tests/helpers.rb
+- tests/profile.rb
+- tests/all
+- tests/unit/tc_span_find_for_day.rb
+- README.rdoc
+- bin/did
+- bin/did_autocomplete
+homepage: http://github.com/adparadise/did
+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.3
+signing_key: 
+specification_version: 3
+summary: Time tracking for the non-clairvoyant
+test_files: []
+