repo_timetracker 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06c97cf5c1df3cf2c5267ac65d0d76fea7620550
+  data.tar.gz: 0292470662a50a0f57d35c50efbeb24fe7cb9e39
+SHA512:
+  metadata.gz: dbca4eb49f6714d723b8d5cdbbb7357890bc38790b530c5917cd2d1af4dc11db8cd802ece8542fb2b49ca2452d9afb9c7424a4c77260a8238f64d8e8ecea2895
+  data.tar.gz: 8c1e50551bf28a8e0887fb58e4cd4eb91a546cb4524c63b32e1e7f6bad20bc1d388bbc46846210649ceb3370aeaf373f52a92782d885c2911563efbe945aa417

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-*
+.repo_timeline

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 M
+
+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,173 @@
+# README
+
+This program times how long you spend on each git commit in a repo without needing a user to start or stop the timer manually.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'repo_timetracker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install repo_timetracker
+
+### How it works
+
+It keeps track of work time by recording the timing of file changes, and of commands used within a project folder.
+
+The exact time of each command recorded with the 'record' command and every file change in the repo is saved, along with whether or not the program thinks you were working during the intervals between these events. When commit_time is called, it adds up all of the time intervals during which it thinks you were working and returns the total.
+
+If two sequential events occur more than half an hour apart, it assumes you weren't working during that time. Less than half an hour, it assumes you were.
+
+Here's an example sequence of events:
+
+```
+> rpt record
+
+...5 minutes pass...
+
+file change
+
+...45 minutes pass...
+
+> rpt record 'git status'
+
+...5 minutes pass...
+
+file change
+
+...5 minutes pass...
+
+file change
+
+> rpt commit_time
+"00:15:00"
+```
+
+At the end, the commit_time command says 15 minutes have been spent working, because it counted the 3 5-minute intervals, but not the one 45-minute interval.
+
+All data is stored in YAML files in the **.repo_timeline** directory, and is pretty easy to read and modify by hand if you're so inclined (for example, to correct one of the intervals from working to not or vice versa if the 30-minute rule fails you).
+
+## How to use
+
+To initialize recording for a repo (only needs to happen once per repo, ever):
+
+``` 
+> rpt record
+
+```
+To get time spent on current commit (in hh:mm:ss):
+
+``` 
+> rpt commit_time
+"00:23:34"
+
+```
+To get total time spent on all commits in this repo (in hh:mm:ss):
+
+``` 
+> rpt project_time
+"07:38:55"
+
+```
+Recording a git commit starts a new commit timer from zero:
+
+```
+> rpt commit_time
+"00:35:23"
+> git commit -am "awesome commit message $(rpt commit_time)"
+[master c2f2492] awesome commit message 00:35:33
+ 1 file changed, 0 insertions(+), 0 deletions(-)
+ rename cool_file.rb => rad_file.rb (100%)
+ 
+> rpt record "git commit"
+> rpt commit_time
+"00:00:06"
+```
+
+## The commands
+
+Commands are called with **rpt** followed by the name of the command.
+
+#### record
+'record' or 'rec' makes a record of an event that occurs within the project directory. The first time this command is run in a directory it will initialize the **.repo_timeline** folder in the root directory of that repo*. This folder is where the timing data is stored. It should be added to your **.gitignore** file.
+
+***For repo_timetracker to work properly, 'git commit' and 'git commit --amend' calls must always be recorded.***
+
+Example call: `rpt record 'git status'`
+
+#### commit_time
+'commit_time' or 'ct' returns the amount of time that has been spent on the current commit thus far in *hh:mm:ss* format.
+
+Example call: `rpt commit_time`
+
+#### project_time
+'project_time' or 'pt' returns the amount of time that has been spent on the entire repo thus far in *hh:mm:ss* format.
+
+Example call: `rpt project_time`
+
+
+### What I use it for
+
+For my purposes, I have setup a function, `rpt`, that runs the rpt script, and some functions that call `rpt record` automatically after common git commands (e.g. `git status` will be followed by `rpt record 'git status'`, `git commit` by `rpt record 'git commit'`, etc.). I use the [fish shell](http://fishshell.com/), so for me these functions look like these:
+
+```
+function gs
+  git status $argv
+  rpt rec "git status $argv"
+end
+```
+```
+function gca
+  git commit --amend $argv
+  rpt rec "git commit --amend $argv"
+end
+```
+
+The function I use for git commits is setup so that it automatically appends the time spent on the commit to the end of the commit message:
+
+```
+function gc
+  set -x totaltime (rpt commit_time)
+  git commit -m "$argv $totaltime" # Commits with time elapsed added on to commit message
+  rpt rec "git commit -m \"$argv $totaltime\"" # Records commit event
+end
+```
+Thus:
+
+```
+> gc "awesome commit message"
+```
+Might produce a commit like:
+
+```
+[master c2f2492] awesome commit message 00:35:33
+1 file changed, 0 insertions(+), 0 deletions(-)
+rename cool_file.rb => rad_file.rb (100%)
+```
+
+I also have a display of the time spent in the current commit show in my terminal prompt, like this:
+```
+00:34:16 >
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/repo_timetracker/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+-----
+
+\* It automatically determines the relevant repo as either a repo in the directory it is called from, or the nearest repo that appears in a parent of that directory.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/rpt

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/repo_timetracker'
+
+case ARGV[0]
+
+when /^((rec)|(record))$/
+  RepoTimetracker.record((ARGV[1] or "event not specified"), Dir.pwd)
+
+when /^((ct)|(commit_time))$/
+  p RepoTimetracker.current_commit_time(Dir.pwd)
+  
+when /^((pt)|(project_time))$/
+  p RepoTimetracker.project_time(Dir.pwd)
+
+else
+  puts "Run 'rpt rec' to setup timetracking in a repo."
+  puts "Run 'rpt rec [event to record, e.g. '\"git commit\"]' to record an event."
+  puts "Run 'rpt ct' to see time spent on the current commit."
+  puts "Run 'rpt pt' to see total time spent on the current project."
+end

data/lib/repo_timetracker/commit_record.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+require_relative "commit_record_class"
+
+class CommitRecord
+  require_relative 'event'
+
+  attr_accessor :events, :file_path
+
+  A_LONG_TIME = 30*60 # 30 minutes
+
+  def initialize(project_directory, first_event_string = nil)
+    @project_name = project_directory.slice(/[^\/]*$/)
+    @timeline_directory = "#{project_directory}/.repo_timeline"
+    @file_path = generate_file_path(project_directory)
+
+    @events = []
+    @events << Event.new(first_event_string) if first_event_string
+  end
+
+  def generate_new_event(event_string, following_time_spent = :working)
+    @events << Event.new(event_string, following_time_spent)
+    @events[-2].following_time_spent = :not_working if long_after_previous_event?(@events[-1])
+    save
+  end
+
+  def total_time
+    time = 0
+    @events.each_cons(2) do |pair|
+      time += pair[1].time_recorded - pair[0].time_recorded if pair[0].following_time_spent_working?
+    end
+
+    time.round
+  end
+
+  def add_events(events)
+    @events += events
+    save
+  end
+
+  def get_tail
+    @events[1..-1]
+  end
+
+  def clear_events
+    @events = []
+    save
+  end
+
+  def save
+    File.open(@file_path, "w") { |f| f.puts YAML::dump(self) }
+    self
+  end
+
+  def ==(other_commit)
+      all_events_equal(other_commit) and 
+      @file_path == other_commit.file_path
+  end
+
+
+
+  private
+
+  def generate_file_path(directory)
+    "#{@timeline_directory}/#{generate_file_name}"
+  end
+
+  def generate_file_name
+    time_string = Time.now.strftime('%y-%m-%d_%Hh%Mm%Ss')
+    "#{@project_name}__commit__#{time_string}.yaml"
+  end
+
+  def long_after_previous_event?(event)
+    index_of_this_event = @events.index(event)
+
+    previous_event = @events[index_of_this_event - 1]
+
+    if previous_event
+      time_difference = 
+          (event.time_recorded - previous_event.time_recorded).ceil
+
+      time_difference >= A_LONG_TIME
+    else
+      false
+    end
+  end
+
+  def all_events_equal(other_commit)
+    all_equal = true
+    @events.each_with_index do |c, i|
+      all_equal = false unless c == other_commit.events[i]
+    end
+    all_equal
+  end
+end

data/lib/repo_timetracker/commit_record_class.rb

@@ -0,0 +1,14 @@
+class CommitRecord
+  class << self
+
+    def create(project_directory, first_event_string = nil)
+      commit = new(project_directory, first_event_string)
+      commit.save
+    end
+
+    def load(commit_file_path)
+      YAML::load(IO.read(commit_file_path).to_s)
+    end
+
+  end
+end

data/lib/repo_timetracker/event.rb

@@ -0,0 +1,19 @@
+class Event
+  attr_accessor :string, :time_recorded, :following_time_spent 
+
+  def initialize(string, following_time_spent = nil)
+    @string = string
+    @time_recorded = Time.now
+    @following_time_spent = following_time_spent || :working
+  end
+
+  def following_time_spent_working?
+    following_time_spent == :working
+  end
+
+  def ==(other_event)
+    @string == other_event.string and 
+    @time_recorded == other_event.time_recorded and 
+    @following_time_spent == other_event.following_time_spent
+  end
+end

data/lib/repo_timetracker/repo_timeline.rb

@@ -0,0 +1,130 @@
+require 'filewatcher'
+require 'fileutils'
+require_relative 'repo_timeline_class'
+require_relative 'commit_record'
+
+class RepoTimeline
+
+  def initialize(repo_directory)
+    @repo_directory = repo_directory.sub(/\/$/, '') #no trailing slash
+    @project_name = @repo_directory.slice(/[^\/]*$/)
+
+    @timeline_directory = initialize_timeline_directory_for(@repo_directory)
+    @commit_records = load_commit_records
+    watch_for_file_change_events
+  end
+
+  def add_event(event_string)
+    case event_string
+    when /git commit --amend/
+      amend(event_string)
+      
+    when /git commit/
+      commit(event_string)
+      
+    else
+      staging.generate_new_event(event_string)
+    end
+  end
+
+  def current_commit_time
+    staging.total_time
+  end
+
+  def project_time
+    time = 0
+    @commit_records.inject(0) { |total_time, cr| 
+      total_time + cr.total_time
+    }
+  end
+
+
+  private
+
+  def commit(event_string)
+    staging.generate_new_event(event_string)
+
+    @commit_records << CommitRecord.create(
+                                            @repo_directory, 
+                                            event_string
+                                            )
+  end
+
+  def amend(event_string)
+    last_completed_commit.add_events(staging.get_tail)
+    last_completed_commit.generate_new_event(event_string)
+
+    staging.clear_events
+    staging.generate_new_event(event_string)
+  end
+
+  def staging
+    if @commit_records.empty?
+      @commit_records << CommitRecord.create(@timeline_directory)
+    else
+      @commit_records.last
+    end
+  end
+
+  def last_completed_commit
+    @commit_records[-2]
+  end
+
+  def load_commit_records
+    if commit_file_paths.empty?
+      CommitRecord.create(@repo_directory)
+    end
+
+    commit_file_paths.map { |p| CommitRecord.load(p) }
+  end
+
+  def initialize_timeline_directory_for(repo_directory)
+    timeline_directory = "#{repo_directory}/.repo_timeline"
+    gitignore_path = "#{repo_directory}.gitignore"
+
+    ensure_gitignored(timeline_directory)
+
+    timeline_directory
+  end
+
+  def ensure_gitignored(timeline_directory)
+    gitignore_path = timeline_directory.sub('.repo_timeline', '.gitignore')
+    
+    FileUtils.touch(gitignore_path)
+
+    unless File.readlines(gitignore_path).grep(/\.repo_timeline/)
+      open(gitignore_path, 'a') { |f| f.puts "\n.repo_timeline" }
+    end
+  end
+
+  def commit_file_paths
+    dir_filenames = Dir.entries(@timeline_directory)
+    commit_filenames = dir_filenames.select { |f| f.include? '__commit__' }
+    commit_filenames.map { |fn| "#{@timeline_directory}/#{fn}" }
+  end
+
+
+  def watch_for_file_change_events
+    if defined? Process.daemon
+      kill_previous_commit_timeline_process
+
+      Process.daemon
+      
+      FileWatcher.new([@repo_directory]).watch do |filename|
+        staging.generate_new_event("File changed: #{filename}")
+      end
+    end
+  end
+
+  def kill_previous_commit_timeline_process
+    similar_processes = `ps -ax | grep repo_timetracker.rb`.split("\n")
+
+    if previous_commit_timeline_process = similar_processes.find { |p| not p.include? 'grep' }
+      previous_commit_timeline_pid = previous_commit_timeline_process.match(/\d+/)[0]
+      if previous_commit_timeline_pid != Process.pid.to_s 
+        Process.kill("HUP", Integer(previous_commit_timeline_pid))
+      end
+
+    end
+  end
+end

data/lib/repo_timetracker/repo_timeline_class.rb

@@ -0,0 +1,32 @@
+class RepoTimeline
+  class << self
+
+    def load_or_initialize_for(directory_called_from)
+      directory = find_in_or_above(directory)
+      timeline_directory = "#{directory}/.repo_timeline"
+
+      return 'No repo found.' if directory.nil?
+
+      RepoTimeline.new(directory)
+    end
+
+    def find_in_or_above(directory)
+
+      if contains_repo? directory
+        directory
+      elsif directory.slice!(/\/\w+(\/?)$/)
+        get_closest_repository_root(directory)
+      else
+        nil
+      end
+    end
+
+
+
+    private
+
+    def contains_repo?(directory_path)
+      Dir.glob("#{directory_path}/.git").any?
+    end
+  end
+end

data/lib/repo_timetracker/version.rb

@@ -0,0 +1,3 @@
+module RepoTimetracker
+  VERSION = "1.0.1"
+end

data/lib/repo_timetracker.rb

@@ -0,0 +1,27 @@
+require_relative "repo_timetracker/version"
+require_relative "repo_timetracker/repo_timeline"
+
+module RepoTimetracker
+  class << self
+    def record(event_string, directory)
+      repo_timeline = RepoTimeline.load_or_initialize_for(directory)
+      repo_timeline.add_event(event_string)
+    end
+
+    def current_commit_time(directory)
+      repo_timeline = RepoTimeline.load_or_initialize_for(directory)
+
+      time = repo_timeline.current_commit_time
+
+      Time.at(time).utc.strftime("%H:%M:%S")
+    end
+
+    def project_time(directory)
+      repo_timeline = RepoTimeline.load_or_initialize_for(directory)
+
+      time = repo_timeline.project_time
+      
+      Time.at(time).utc.strftime("%H:%M:%S")
+    end
+  end
+end

data/repo_timetracker.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'repo_timetracker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "repo_timetracker"
+  spec.version       = RepoTimetracker::VERSION
+  spec.authors       = ["neurodynamic"]
+  spec.email         = ["developer@neurodynamic.io"]
+  spec.summary       = %q{A timetracker for git commits.}
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "filewatcher", "~> 0.4.0"
+  spec.add_development_dependency "minitest", ">= 5.4.0"
+  spec.add_development_dependency "timecop", "~> 0.7.1"
+end

data/spec/commit_record_spec.rb

@@ -0,0 +1,177 @@
+require 'minitest/autorun'
+require 'timecop'
+require 'yaml'
+require_relative "../lib/repo_timetracker/commit_record"
+require_relative "spec_helper"
+
+describe CommitRecord do
+  before(:each) do
+    Timecop.return
+    @app_folder = "./spec/test_app"
+    FileUtils::mkdir_p "#{@app_folder}/.repo_timeline" unless File.directory?("#{@app_folder}/.repo_timeline")
+
+    clear_test_app_timeline_folder
+  end
+
+  describe "new" do
+    it "should create a new commit with no events if no event string given" do
+      CommitRecord.new(@app_folder).events.any?.must_equal false
+    end
+
+    it "should create a new commit with a events if event string given" do
+      CommitRecord.new(@app_folder, 'bangin_event').events.length.must_equal 1
+    end
+
+    it "should set file_path based on project name and time" do
+      Timecop.freeze(Time.now) do
+        commit = CommitRecord.new(@app_folder, 'overzealous_event')
+        commit.file_path.must_equal "#{@app_folder}/.repo_timeline/test_app__commit__#{Time.now.strftime('%y-%m-%d_%Hh%Mm%Ss')}.yaml"
+      end
+    end
+  end
+
+  describe "generate_new_event" do
+    before(:each) do
+      @commit = CommitRecord.new(@app_folder)
+    end
+
+    it "should add a new event" do
+      @commit.events.must_be :empty?
+
+      @commit.generate_new_event 'awesome_event'
+
+      @commit.events.length.must_equal 1
+      @commit.events.last.string.must_equal 'awesome_event'
+    end
+
+    it "should set previous event to :not_working if event issued 30+ min after previous event" do
+      @commit.generate_new_event 'cool_event'
+
+      Timecop.freeze(Time.now + 30*60) do
+        @commit.generate_new_event 'much_later_event_that_is_still_cool'
+      end
+
+      @commit.events.first.following_time_spent.must_equal :not_working
+    end
+
+    it "should NOT set previous event to :not_working if less than 30min time difference" do
+      @commit.generate_new_event 'cool_event'
+
+      Timecop.freeze(Time.now + 30*60 - 2) do
+        @commit.generate_new_event 'temporally_proximitous_event'
+      end
+
+      @commit.events.first.following_time_spent.must_equal :working
+    end
+  end
+
+  describe "total_time" do
+    before(:each) do
+      @commit = CommitRecord.new(@app_folder)
+    end
+
+    it "should return zero if no events in commit" do
+      @commit.total_time.must_equal 0
+    end
+
+    it "should return zero if only one event in commit" do
+      @commit.generate_new_event('sad_event')
+      @commit.total_time.must_equal 0
+    end
+
+    it "should total time between all event pair intervals of less than 30 minutes" do
+      
+      Timecop.freeze(Time.now) do
+        @commit.generate_new_event('sad_event')
+      end
+
+      Timecop.freeze(Time.now + 25*60) do
+        @commit.generate_new_event 'lonely_event'
+      end
+
+      Timecop.freeze(Time.now + 60*60) do
+        @commit.generate_new_event 'philosophically_confused_event'
+      end
+
+      Timecop.freeze(Time.now + 75*60) do
+        @commit.generate_new_event 'untrustworthy_event'
+      end
+
+      @commit.total_time.must_equal(75*60 - 35*60)
+    end
+  end
+
+  describe "add_events" do
+    it "should add array of events to current events" do
+      @commit = CommitRecord.new(@app_folder, 'eventant')
+
+      @commit.events.length == 1
+      @commit.add_events([
+        Event.new('badly_spelllled_event'),
+        Event.new('obsequious_event'),
+        Event.new('event_which_must_not_be_named')
+        ])
+
+      @commit.events.length.must_equal 4
+    end
+  end
+
+  describe "get_tail" do
+    it "should return tail of events array" do
+      @commit = CommitRecord.new(@app_folder, 'coming_up_with_names_for_these_is_hard')
+
+      @commit.get_tail.must_equal []
+      @commit.generate_new_event 'oh_well'
+      @commit.get_tail.length.must_equal 1
+    end
+  end
+
+  describe "clear_events" do
+    it "should make events array equal to []" do
+      @commit = CommitRecord.new(@app_folder, 'blah')
+      @commit.events.wont_equal []
+      @commit.clear_events
+      @commit.events.must_equal []
+    end
+  end
+
+  describe "==" do
+    it "should return true if all events and file_path are equal" do
+      Timecop.freeze(Time.now) do
+        @commit_1 = CommitRecord.new(@app_folder, 'blah')
+        @commit_2 = CommitRecord.new(@app_folder, 'blah')
+      end
+
+      @commit_1.must_equal @commit_2
+    end
+
+    it "should return false if any events are not equal" do
+      Timecop.freeze(Time.now) do
+        @commit_1 = CommitRecord.new(@app_folder, 'blah')
+        @commit_2 = CommitRecord.new(@app_folder, 'blahblah')
+      end
+
+      @commit_1.wont_equal @commit_2
+    end
+
+    it "should return false if filepaths are not equal" do
+      @commit_1 = CommitRecord.new(@app_folder, 'blah')
+      @commit_2 = @commit_1.dup
+      @commit_2.file_path = 'fkdlsajfl'
+
+      @commit_1.wont_equal @commit_2
+    end
+  end
+
+  describe "save" do
+    it "should write commit info to yaml file named by file_path variable" do
+      file_path = "#{@app_folder}/.repo_timeline/test_save_file.yml"
+
+      @commit = CommitRecord.new(@app_folder, 'blah')
+      @commit.file_path = file_path
+      @commit.save
+
+      @commit.must_equal YAML::load(IO.read(file_path))
+    end
+  end
+end

data/spec/event_spec.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'timecop'
+require_relative "../lib/repo_timetracker/event"
+require_relative "spec_helper"
+
+describe Event do
+  before(:each) do
+    Timecop.return
+  end
+
+  describe 'new' do
+    it 'should create a new event' do
+      Timecop.freeze
+      event = Event.new('test event')
+
+      event.string.must_equal 'test event'
+      event.time_recorded.must_equal Time.now
+    end
+
+    it 'should set following_time_spent if specified' do
+      event = Event.new('test event', :not_working)
+
+      event.following_time_spent.must_equal :not_working
+    end
+
+    it 'should set following_time_spent to :working if not specified' do
+      event = Event.new('test event')
+
+      event.following_time_spent.must_equal :working
+    end
+  end
+
+  describe 'following_time_spent_working?' do
+
+    it 'should return true if :working' do
+      Event.new('test event', :working).following_time_spent_working?.must_equal true
+    end
+
+    it 'should return false if :not_working' do
+      Event.new('test event', :not_working).following_time_spent_working?.must_equal false
+    end
+  end
+
+  describe '==' do
+    before(:each) do
+      @event = Event.new('test event')
+    end
+
+    it 'should return true if all attributes equal' do
+      @event.must_equal @event.dup
+    end
+
+    it 'should return false if any attributes inequal' do
+      @event.wont_equal Event.new('different test event')
+
+      @different_time_event = @event.dup
+      @different_time_event.time_recorded = 
+      @different_time_event.time_recorded + 5
+
+      @event.wont_equal @different_time_event
+
+      @different_time_event = @event.dup
+      @different_time_event.following_time_spent = :not_working
+      @event.wont_equal @different_time_event
+    end
+
+    describe 'following_time_spent_working?' do
+
+      it 'should return true if :working' do
+        Event.new('test event', :working).following_time_spent_working?.must_equal true
+      end
+
+      it 'should return false if :not_working' do
+        Event.new('test event', :not_working).following_time_spent_working?.must_equal false
+      end
+    end
+  end
+end

data/spec/repo_timeline_spec.rb

@@ -0,0 +1,119 @@
+require 'minitest/autorun'
+require "timecop"
+require_relative '../lib/repo_timetracker/repo_timeline'
+
+# redefining this method so that test_app 
+# folder will be used instead of the real repo_timetracker repo
+class RepoTimeline
+  def self.find_in_or_above(directory)
+    './spec/test_app'
+  end
+end
+
+class RepoTimeline
+  def watch_for_file_change_events
+    # Disabled for testing because forking screws with tests running
+  end
+end
+
+
+describe RepoTimeline do
+  before(:each) do
+    Timecop.return
+    clear_test_app_timeline_folder
+    @repo_timeline = RepoTimeline.new('./spec/test_app')
+  end
+
+  describe "current_commit_time" do
+    it 'should return zero if no data' do
+
+      @repo_timeline.current_commit_time
+    end
+  end
+
+  it 'should return no time spent if only one event recorded' do
+    @repo_timeline.add_event('event')
+    @repo_timeline.current_commit_time.must_equal 0
+    @repo_timeline.project_time.must_equal 0
+  end
+
+  it 'should return sum of time differences of all recorded events under 30min apart' do
+    Timecop.freeze(Time.now)
+    @repo_timeline.add_event('event 1')
+
+    Timecop.freeze(Time.now + 30)
+    @repo_timeline.add_event('event 2')
+    @repo_timeline.current_commit_time.must_equal 30
+    @repo_timeline.project_time.must_equal 30
+
+    Timecop.freeze(Time.now + 30)
+    @repo_timeline.add_event('event 3')
+    @repo_timeline.current_commit_time.must_equal 60
+    @repo_timeline.project_time.must_equal 60
+    
+    Timecop.freeze(Time.now + 30*60)
+    @repo_timeline.add_event('event 4')
+    @repo_timeline.current_commit_time.must_equal 60
+    @repo_timeline.project_time.must_equal 60
+    
+    Timecop.freeze(Time.now + 29*60)
+    @repo_timeline.add_event('event 5')
+    @repo_timeline.current_commit_time.must_equal 30*60
+    @repo_timeline.project_time.must_equal 30*60
+  end
+
+  describe "when a commit happens" do
+    before(:each) do
+      @repo_timeline = RepoTimeline.new('./spec/test_app')
+
+      Timecop.freeze(Time.now)
+      @repo_timeline.add_event('event 1')
+      Timecop.freeze(Time.now + 30)
+      @repo_timeline.add_event('event 2')
+      Timecop.freeze(Time.now + 30)
+      @repo_timeline.add_event('event 3')
+      Timecop.freeze(Time.now + 29*60)
+      @repo_timeline.add_event('event 4')
+    end
+
+    it "should return time in new commit only" do
+      Timecop.freeze(Time.now + 5*60)
+      @repo_timeline.add_event('git commit "commit message"')
+      @repo_timeline.current_commit_time.must_equal 0
+      @repo_timeline.project_time.must_equal 35*60
+
+      Timecop.freeze(Time.now + 5*60)
+      @repo_timeline.add_event('event 6"')
+      @repo_timeline.current_commit_time.must_equal 5*60
+      @repo_timeline.project_time.must_equal 40*60
+
+    end
+  end
+
+  describe "when an amend happens" do
+    before(:each) do
+      Timecop.freeze(Time.now)
+      @repo_timeline.add_event('event 1')
+      Timecop.freeze(Time.now + 30)
+      @repo_timeline.add_event('event 2')
+      Timecop.freeze(Time.now + 30)
+      @repo_timeline.add_event('event 3')
+      Timecop.freeze(Time.now + 29*60)
+      @repo_timeline.add_event('event 4')
+      Timecop.freeze(Time.now + 5*60)
+      @repo_timeline.add_event('git commit "commit message"')
+    end
+
+    it "should return time in new commit only" do
+      Timecop.freeze(Time.now + 5*60)
+      @repo_timeline.add_event('event 6"')
+      @repo_timeline.current_commit_time.must_equal 5*60
+      @repo_timeline.project_time.must_equal 40*60
+
+      Timecop.freeze(Time.now + 5*60)
+      @repo_timeline.add_event('git commit --amend"')
+      @repo_timeline.current_commit_time.must_equal 0
+      @repo_timeline.project_time.must_equal 45*60
+    end
+  end
+end

data/spec/spec.rb

@@ -0,0 +1,7 @@
+
+
+require 'minitest/autorun'
+require_relative "spec_helper"
+require_relative "event_spec"
+require_relative "commit_record_spec"
+require_relative "repo_timeline_spec"

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+def commit_filenames
+  Dir.entries("./spec/test_app/.repo_timeline").select { |f| f.include? '__commit__' }
+end
+
+def clear_test_app_timeline_folder
+  Dir.entries("./spec/test_app/.repo_timeline").select { |f| f.include? '__commit__' }.each do |f|
+    File.delete("./spec/test_app/.repo_timeline/#{f}")
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: repo_timetracker
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- neurodynamic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: filewatcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: ''
+email:
+- developer@neurodynamic.io
+executables:
+- rpt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rpt
+- lib/repo_timetracker.rb
+- lib/repo_timetracker/commit_record.rb
+- lib/repo_timetracker/commit_record_class.rb
+- lib/repo_timetracker/event.rb
+- lib/repo_timetracker/repo_timeline.rb
+- lib/repo_timetracker/repo_timeline_class.rb
+- lib/repo_timetracker/version.rb
+- repo_timetracker.gemspec
+- spec/commit_record_spec.rb
+- spec/event_spec.rb
+- spec/repo_timeline_spec.rb
+- spec/spec.rb
+- spec/spec_helper.rb
+- spec/test_app/.gitignore
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A timetracker for git commits.
+test_files:
+- spec/commit_record_spec.rb
+- spec/event_spec.rb
+- spec/repo_timeline_spec.rb
+- spec/spec.rb
+- spec/spec_helper.rb
+- spec/test_app/.gitignore