tlog 0.0.8 → 0.0.9

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDE3OGNjNzJlOGFjNmZiYmMxZWQ5ZGJkMmI0ZTE5NDZmZGE5ZGFlNw==
+    MGExZGJhMGE1OTc4ZTRkNTVjMGZhNjhjNDEzYjdhZmQ4MGMwMTRmYQ==
   data.tar.gz: !binary |-
-    NjVmYTY3OTExZjhmZWEzODhkMTI4NTkwNDUwZDc0NmUwY2Q3ZDk3OQ==
+    NzIwMGE5NDQ5ZmFkY2RhOTkxNGEzNDA0NmNkZjdiN2Y3N2RhNDg5Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OGM2NDFkNDFhNTExMWM5ZmQ1NmY1M2U0MTRmM2I2NzY5NGM0ZDBjNDFhMzRl
-    OTBkYzYwYjI5YmMyOTJhNzhkYTFiZDMyYzg5NWU0NzczNjVjZmM2NzkwM2Rm
-    NTM1YWExN2EwMGQ0NjU4MDAzZDM5YWJmYmRjNjQ1NjUyMGFjYmI=
+    NjE1MTg1N2FmNzY3Y2QwZTIxOWFhNzk4MDgwZmRhMDlhNTRiZWVlYTZlMDg5
+    MDhiOWFlNjQyMDc0ZWIzOGQ0NjdlNjY4MmIyNWVlZDQ4ZmNhZDEzMjliMzFj
+    YTE4NWExYWI0NDNjMzk5M2JjNTZhNjEzNmZhMGJhMTc4NThhMTc=
   data.tar.gz: !binary |-
-    Zjk5NTIwODE3ODYxMzBiMzQ0YTY4MzdmODIxYjE1YzQyMjE5MjhjNjcyY2Y2
-    ZWY3ZTI5NmRiZTBiYzI4ZTIwODM1YWI4ZDhjNTIzZmU0MzAxMTQ4OWY3ZGQ0
-    ZGNkZjI3Y2UzNjNiYzhkYWI2M2IzMmU4MDE2ZDdiZTkyOTU4Y2Y=
+    M2RmMDI5NGNkZDFlNTIwMTUyN2EyZDAyNjkyYWYwZjRhNWMzMjBjOWIyMGZi
+    YjcwMTBiZDE5ZjcyYzc1OWFiN2JkOWE5ODY4YjdkOTdiOGRhNjcwNDBiMTYw
+    MTBjNjlkZDgwMjUxNzdlNTllMjA2NzcyN2Q2MDUyNzMwOGVmYWU=

data/README.md

@@ -1,9 +1,80 @@
 tlog
-====
+============================================
 
-CLI time tracking tool
+A git-based CLI to help you with time tracking on your projects.
 
-##TODO
-- write a read me lol
+## Installing
+```bash
+$ sudo gem install tlog
+```
 
+## Usage
+* Navigate to a directory that has a git repo
 
+### Create a time log
+```bash
+$ tlog create example 
+```
+
+### Check out a time log
+```bash
+$ tlog checkout example
+```
+
+### Create a time log with a time goal
+```bash
+$ tlog create example --goal 4hr
+```
+
+### Start a new task on a time log
+```bash
+$ tlog start example -d "My task description"
+```
+
+### Stop the current task
+```bash
+$ tlog stop example
+```
+
+### Show active time logs and label the current one, if it exists
+```bash
+$ tlog active
+All Time Logs:
+testing
+feature1(current)
+bug fix
+feature2
+```
+ 
+### Display all the current time logs and their tasks, total time logged and time left.
+```bash
+$ tlog display
+Log: example1
+	Start               End                    Duration        Owner          Description
+	May 29, 11:57PM    May 29, 11:58PM         0:01:13         chriwend       My Description
+----------------------------------------------------------------------------------------------------
+	Total                                      0:01:13 
+Log: example2
+	Start               End                    Duration        Owner          Description
+	May 30, 12:00AM                            0:02:26         chriwend       Fixing bug
+	May 30, 12:00AM    May 30, 12:00AM         0:00:10         chriwend       (no description)
+----------------------------------------------------------------------------------------------------
+	Total                                      0:02:36 
+	Time left:                                 3:57:24
+``` 
+
+### Delete a time log
+```bash
+$ tlog delete example
+```
+
+## Collaboration
+More to come on this after I test it...
+
+## Contributing
+
+Please look at the TODO for possible additional features. Use [Github issues](https://github.com/cewendel/tlog/issues) to track bugs and feature requests.
+
+## Licence
+
+GNU GENERAL PUBLIC LICENCE Version 2

data/lib/tlog.rb

@@ -24,14 +24,20 @@ require 'chronic'
 require "optparse"
 require "colorize"
 
+require 'tlog/command_suite'
+
 require 'tlog/command'
-require 'tlog/command/init'
 require 'tlog/command/start'
 require 'tlog/command/stop'
 require 'tlog/command/active'
 require 'tlog/command/delete'
 require 'tlog/command/display'
 require 'tlog/command/create'
+require 'tlog/command/help'
+require 'tlog/command/checkout'
+require 'tlog/command/state'
+require 'tlog/command/owner'
+require 'tlog/command/points'
 
 require 'tlog/storage/disk'
 

data/lib/tlog/application.rb

@@ -18,44 +18,26 @@ class Tlog::Application
 			@output.error($!)
 			@output.error(@optparse.to_s)
 		rescue Tlog::Error::CommandInvalid
-			@output.error(command_name + " syntax invalid: " + $!.message)
+			@output.error(command_name + " command invalid: " + $!.message)
+			@output.error(@optparse.to_s)
+		rescue Tlog::Error::CommandNotFound, OptionParser::MissingArgument
+			@output.error($!)
 			@output.error(@optparse.to_s)
-		rescue Tlog::Error::CommandNotFound
-			@output.error(command_name +": " + $!.message) # format class?
 		rescue
 			@output.error($!)
 		end
 		return outcome
 	end
 
-	def all_commands
-		storage = working_dir_storage
-		commands = [
-			Tlog::Command::Init.new,
-			Tlog::Command::Start.new,
-			Tlog::Command::Stop.new,
-			Tlog::Command::Active.new,
-			Tlog::Command::Delete.new,
-			Tlog::Command::Display.new,
-			Tlog::Command::Create.new,
-		]
-		commands.each do |command|
-			command.storage = storage
-			command.seconds_format = Tlog::Format::Seconds
-			command.date_time_format = Tlog::Format::DateTime
-		end
-		return commands
-	end
-
-
 	private
 
-	def working_dir_storage
-		Tlog::Storage::Disk.new('.')
-	end
-
 	def find(command_name)
-		all_commands.select { |command| command.name == command_name }.first
+		commands = Tlog::Command_Suite.commands
+		command = nil
+		commands.each do |cmd|
+			return cmd if cmd.name == command_name
+		end
+		command
 	end
 
 	def prepare_command(command)
@@ -72,7 +54,7 @@ class Tlog::Application
 			command.execute(@input, @output)
 			true
 		else
-			raise Tlog::Error::CommandNotFound, "Command not found"
+			raise Tlog::Error::CommandNotFound, "Command not found, use 'tlog help' for list of commands"
 		end
 	end
 

data/lib/tlog/command/active.rb

@@ -1,11 +1,15 @@
+
 class Tlog::Command::Active < Tlog::Command
 
 	def name 
 		"active"
 	end 
 
+	def description
+		"prints out all active time logs, the time log in-progress if there is one. Or the currently checked-out time log"
+	end
+
 	def execute(input, output)
-		output.line("execute on active command") #change to out
 		print_time_entry(output)
 	end
 
@@ -23,6 +27,7 @@ class Tlog::Command::Active < Tlog::Command
 				log_name = log.basename.to_s
 				active_log = Tlog::Entity::Active_Log.new(log_name)
 				active_log.current = true if storage.current_log_name == log_name
+				active_log.checked_out = true if storage.checkout_value == log_name
 				active_logs.push(active_log)
 			end
 			output.line_yellow("All Time Logs:")
@@ -32,12 +37,15 @@ class Tlog::Command::Active < Tlog::Command
 
 	def print_logs(active_logs, output)
 		active_logs.each do |active_log|
+			out_line = active_log.name
 			if active_log.current
-				out_line = active_log.name
-				out_line << " (current)"
+				out_line << " (in-progress)"
 				output.line_red(out_line);
+			elsif active_log.checked_out
+				out_line << " (checked_out)"
+				output.line_blue(out_line)
 			else
-				output.line(active_log.name)
+				output.line(out_line)
 			end
 		end
 	end

data/lib/tlog/command/checkout.rb

@@ -0,0 +1,31 @@
+
+class Tlog::Command::Checkout < Tlog::Command
+
+	def name
+		"checkout"
+	end
+
+	def description 
+		"checkouts a time log in order to start tasks on"
+	end
+
+	def execute(input, output)
+		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
+		checkout(input.args[0])
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog checkout <log_name>"
+	end
+
+	private
+
+	def checkout(log_name)
+		storage.in_branch do |wd|
+			log = storage.require_log(log_name)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{log_name}' does not exist" unless log
+			storage.checkout_log(log)
+		end
+	end
+
+end

data/lib/tlog/command/create.rb

@@ -5,13 +5,17 @@ class Tlog::Command::Create < Tlog::Command
 		"create"
 	end
 
+	def description 
+		"creates a new time log either with no goal or with a goal"
+	end
+
 	def execute(input, output)
 		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
 
 		log = Tlog::Entity::Log.new
 		log.name = input.args[0];
 		log.goal = ChronicDuration.parse(input.options[:goal]) if input.options[:goal]
-		raise Tlog::Error::CommandNotFound, "Could create log: Log already exists" unless create_log(log)
+		raise Tlog::Error::CommandInvalid, "Could create log: Log already exists" unless create_log(log)
 	end
 
 	def options(parser, options)
@@ -26,7 +30,7 @@ class Tlog::Command::Create < Tlog::Command
 
 	def create_log(log)
 		storage.in_branch do |wd|
-			storage.create_log(log)
+			raise Tlog::Error::CommandInvalid, "Time log '#{log.name}' already exists" unless storage.create_log(log)
 		end
 	end
 end

data/lib/tlog/command/delete.rb

@@ -4,6 +4,10 @@ class Tlog::Command::Delete < Tlog::Command
 		"delete"
 	end
 
+	def description
+		"deletes a time log"
+	end
+
 	def execute(input, output)
 		raise Tlog::Error::CommandInvalid, "Task does not exist" unless delete(input.args[0])
 	end
@@ -17,7 +21,8 @@ class Tlog::Command::Delete < Tlog::Command
 	def delete(log_name)
 		storage.in_branch do |wd|
 			log = storage.require_log(log_name)
-			storage.delete_log(log) if log
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{log_name}' does not exist" unless log
+			storage.delete_log(log) 
 		end
 	end
 

data/lib/tlog/command/display.rb

@@ -1,10 +1,15 @@
 
+# I will forever love whoever re-writes this class (badly needed) 
 class Tlog::Command::Display < Tlog::Command
 
 	def name
 		"display"
 	end
 
+	def description
+		"displays shit"
+	end 
+
 	def execute(input, output)
 		raise Tlog::Error::CommandInvalid, "Logging invalid" unless display(input.args[0], input.options[:length], output)
 	end
@@ -37,7 +42,7 @@ class Tlog::Command::Display < Tlog::Command
 			start_time = Time.parse(storage.start_time_string)
 		end
 		return if length_exceeds_threshold?(log_length, length_threshold)
-		print_log_name(log_name, output)
+		print_log_info(log, output)
 		print_header(output)
 		print_current(log_name, log_length, start_time, output)
 		display_entries(entries, output) if entries
@@ -54,11 +59,10 @@ class Tlog::Command::Display < Tlog::Command
 	def display_entries(entries, output)
 		if entries.size > 0
 			entries.each do |entry|
-				out_str = "\t%-4s   %16s  %14s   %14s       %s" % [
+				out_str = "\t%-4s   %16s %14s           %s" % [
 					date_time_format.timestamp(entry.time[:start]),
 					date_time_format.timestamp(entry.time[:end]),
 					seconds_format.duration(entry.length.to_s),
-					entry.owner,
 					entry.description,
 				]
 				output.line(out_str)
@@ -73,7 +77,7 @@ class Tlog::Command::Display < Tlog::Command
 	end
 
 	def print_header(output)
-		output.line("\tStart               End                    Duration        Owner          Description")
+		output.line("\tStart               End                    Duration          Description")
 	end 
 
 	def print_total(log, output)
@@ -85,8 +89,9 @@ class Tlog::Command::Display < Tlog::Command
 		output.line("\tTotal%45s " % seconds_format.duration(duration))
 	end
 
-	def print_log_name(log_name, output)
-		output.line_yellow("Log: #{log_name}")
+	def print_log_info(log, output)
+		out_str = "Log:    #{log.name}\nState:  #{log.state}\nPoints: #{log.points}\nOwner:  #{log.owner}"
+		output.line_yellow(out_str)
 	end
 
 	def print_time_left(log, output)
@@ -105,11 +110,10 @@ class Tlog::Command::Display < Tlog::Command
 	def print_current(log_name, log_length, current_start_time, output)
 		if is_current_log_name?(log_name)
 			formatted_length = seconds_format.duration storage.time_since_start
-			out_str = out_str = "\t%-4s  %16s   %14s   %14s       %s" % [
+			out_str = out_str = "\t%-4s  %16s  %14s           %s" % [
 				date_time_format.timestamp(current_start_time),
 				nil,
 				formatted_length,
-				storage.cur_entry_owner,
 				storage.cur_entry_description, 
 			]
 			output.line(out_str)

data/lib/tlog/command/help.rb

@@ -0,0 +1,38 @@
+
+class Tlog::Command::Help < Tlog::Command
+
+	def name
+		"help"
+	end
+
+	def description
+		"outputs lists of commands and their descriptions"
+	end
+
+	def execute(input, output)
+		commands = Tlog::Command_Suite.commands
+		commands.sort! {|a,b| a.name <=> b.name}
+		max_name_length = 0
+
+		commands.each do |command|
+			name_length = command.name.length
+			max_name_length = name_length if name_length > max_name_length 
+		end
+
+		output.line("usage: tlog <command>")
+		output.line(nil)
+
+		commands.each do |command|
+			line = sprintf("%-#{max_name_length}s  %s", command.name, command.description)
+			output.line(line)
+		end
+
+		output.line(nil)
+		return true
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog help"
+	end
+
+end

data/lib/tlog/command/init.rb

@@ -5,6 +5,10 @@ class Tlog::Command::Init < Tlog::Command
 		"init"
 	end
 
+	def description
+		"fuck"
+	end
+
 	def execute(input,output)
 		if input.args[0].nil?
 			raise Tlog::Error::CommandInvalid, "Project already initialized" unless @storage.init_project

data/lib/tlog/command/owner.rb

@@ -0,0 +1,32 @@
+
+class Tlog::Command::Owner < Tlog::Command
+
+	def name 
+		"owner"
+	end 
+
+	def description
+		"changes the owner of the checked-out time log"
+	end
+
+	def execute(input, output)
+		new_owner = input.args[0]
+		change_owner(new_owner)
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog owner <new_owner>"
+	end
+
+	private
+
+	def change_owner(new_owner)
+		storage.in_branch do |wd|
+			checked_out_log = storage.checkout_value
+			raise Tlog::Error::CheckoutInvalid, "No time log is checked out" unless checked_out_log
+			log = storage.require_log(checked_out_log)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{checked_out_log}' does not exist" unless log
+			storage.change_log_owner(log, new_owner)
+		end
+	end
+end

data/lib/tlog/command/points.rb

@@ -0,0 +1,32 @@
+
+class Tlog::Command::Points < Tlog::Command
+
+	def name 
+		"points"
+	end 
+
+	def description
+		"changes the point value of the checked-out time log"
+	end
+
+	def execute(input, output)
+		new_points_value = input.args[0]
+		change_state(new_points_value)
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog points <new_points_value>"
+	end
+
+	private
+
+	def change_state(points)
+		storage.in_branch do |wd|
+			checked_out_log = storage.checkout_value
+			raise Tlog::Error::CheckoutInvalid, "No time log is checked out" unless checked_out_log
+			log = storage.require_log(checked_out_log)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{checked_out_log}' does not exist" unless log
+			storage.change_log_points(log, points)
+		end
+	end
+end

data/lib/tlog/command/start.rb

@@ -5,13 +5,16 @@ class Tlog::Command::Start < Tlog::Command
 		"start"
 	end 
 
+	def description
+		"starts a new task for a time log"
+	end
+
 	def execute(input, output)
-		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
-		start(input.args[0], input.options[:description])
+		start(input.options[:description])
 	end
 
 	def options(parser, options)
-		parser.banner = "usage: tlog start <log_name>"
+		parser.banner = "usage: tlog start"
 
     	parser.on("-d", "--description <description>") do |description|
     		options[:description] = description
@@ -20,12 +23,15 @@ class Tlog::Command::Start < Tlog::Command
 
 	private
 
-	def start(log_name, entry_description)
+	def start(entry_description)
 		storage.in_branch do |wd|
-			log = storage.require_log(log_name)
-			raise Tlog::Error::CommandNotFound, "Time log '#{log_name}' does not exist" unless log
-			current_owner = storage.cur_entry_owner
-			storage.start_log(log, entry_description)
+			checked_out_log = storage.checkout_value
+			raise Tlog::Error::CheckoutInvalid, "No time log is checked out" unless checked_out_log
+			log = storage.require_log(checked_out_log)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{checked_out_log}' does not exist" unless log
+			unless storage.start_log(log, entry_description)
+				raise Tlog::Error::CommandInvalid, "Time log '#{checked_out_log}' is already in progress"
+			end
 		end
 	end
 end

data/lib/tlog/command/state.rb

@@ -0,0 +1,32 @@
+
+class Tlog::Command::State < Tlog::Command
+
+	def name 
+		"state"
+	end 
+
+	def description
+		"changes the state of the checked-out time log"
+	end
+
+	def execute(input, output)
+		new_state = input.args[0]
+		change_state(new_state)
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog state <new_state>"
+	end
+
+	private
+
+	def change_state(new_state)
+		storage.in_branch do |wd|
+			checked_out_log = storage.checkout_value
+			raise Tlog::Error::CheckoutInvalid, "No time log is checked out" unless checked_out_log
+			log = storage.require_log(checked_out_log)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{checked_out_log}' does not exist" unless log
+			storage.change_log_state(log, new_state)
+		end
+	end
+end

data/lib/tlog/command/stop.rb

@@ -4,21 +4,29 @@ class Tlog::Command::Stop < Tlog::Command
 		"stop"
 	end 
 
+	def description
+		"ends a task for a time log"
+	end
+
 	def execute(input, output)
-		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
-		stop(input.args[0])
+		stop
 	end
 
 	def options(parser, options)
-		parser.banner = "usage: tlog stop <log_name>"
+		parser.banner = "usage: tlog stop"
 	end
 
 	private
 
-	def stop(log_name)
+	def stop
 		storage.in_branch do |wd|
-			log = storage.require_log(log_name)
-			storage.stop_log(log)
+			checked_out_log = storage.checkout_value
+			raise Tlog::Error::CheckoutInvalid, "No time log is checked out" unless checked_out_log
+			log = storage.require_log(checked_out_log)
+			raise Tlog::Error::TimeLogNotFound, "Time log '#{checked_out_log}' does not exist" unless log
+			unless storage.stop_log(log)
+				raise Tlog::Error::CommandInvalid, "Failed to stop log '#{checked_out_log}': This time log is not in progress"
+			end
 		end
 	end
 

data/lib/tlog/command_suite.rb

@@ -0,0 +1,34 @@
+
+# Simple helper class that handles an array of commands
+class Tlog::Command_Suite 
+
+	class << self
+		def commands
+			storage = self.working_dir_storage
+			commands = [
+				Tlog::Command::Start.new,
+				Tlog::Command::Stop.new,
+				Tlog::Command::Help.new,
+				Tlog::Command::Active.new,
+				Tlog::Command::Delete.new,
+				Tlog::Command::Display.new,
+				Tlog::Command::Create.new,
+				Tlog::Command::Checkout.new,
+				Tlog::Command::State.new,
+				Tlog::Command::Points.new,
+				Tlog::Command::Owner.new
+			]
+			commands.each do |command|
+				command.storage = storage
+				command.seconds_format = Tlog::Format::Seconds
+				command.date_time_format = Tlog::Format::DateTime 
+			end
+			commands
+		end
+
+		def working_dir_storage
+			Tlog::Storage::Disk.new('.')
+		end
+	end
+
+end

data/lib/tlog/entity/active_log.rb

@@ -1,11 +1,13 @@
 
 # Helper class for printing out active time logs
 class Tlog::Entity::Active_Log
-	attr_accessor :name
+	attr_reader :name
 	attr_accessor :current
+	attr_accessor :checked_out
 
 	def initialize(name)
 		@name = name
 		@current = false
+		@checked_out = false
 	end
 end

data/lib/tlog/entity/entry.rb

@@ -19,7 +19,7 @@ class Tlog::Entity::Entry
 		write_file(parent_path, parent)
 		write_file(time_path, time_log.strip)
 		write_file(description_path, current[:description])
-		write_file(owner_path, current[:owner])
+		#write_file(owner_path, current[:owner])
 	end
 
 	def parent_hex
@@ -48,10 +48,6 @@ class Tlog::Entity::Entry
 		read_file(description_path)
 	end
 
-	def owner 
-		read_file(owner_path)
-	end
-
 	private
 
 	def write_file(path, content)
@@ -83,8 +79,4 @@ class Tlog::Entity::Entry
 		File.join(@path, 'DESCRIPTION')
 	end
 
-	def owner_path
-		File.join(@path, 'OWNER')
-	end
-
 end

data/lib/tlog/entity/log.rb

@@ -15,6 +15,20 @@ class Tlog::Entity::Log
 		end
 	end
 
+	def create(options)
+		unless Dir.exists?(@path)
+			FileUtils.mkdir_p(@path)
+			state = 'open'
+			points = 0
+			owner = 'none'
+			state = options[:state] if options[:state]
+			points = options[:points] if options[:point]
+			owner = options[:owner] if options[:owner]
+			write_log(state, points, owner)
+			true
+		end
+	end
+
 	def goal_length
 		if File.exists?(goal_path)
 			contents = File.read(goal_path)
@@ -22,7 +36,6 @@ class Tlog::Entity::Log
 			contents.to_i
 		end
 	end
-	
 
 	def entries
 		log_entries = []
@@ -44,15 +57,30 @@ class Tlog::Entity::Log
 		dur
 	end
 
-	def create
-		unless Dir.exists?(@path)
-			FileUtils.mkdir_p(@path)
-			File.open(hold_path, 'w+'){|f| f.write('hold')}
-			File.open(goal_path, 'w'){|f| f.write(@goal)} if @goal
-			true
-		end
+	def owner
+		read_file(owner_path) if File.exists?(owner_path)
+	end
+
+	def state
+		read_file(state_path) if File.exists?(state_path)
+	end
+
+	def points
+		read_file(points_path) if File.exists?(points_path)
+	end
+
+	def update_state(state)
+		File.open(state_path, 'w'){|f| f.write(state)}
 	end
 
+	def update_points(points)
+		File.open(points_path, 'w'){|f| f.write(points)}
+	end
+
+	def update_owner(owner)
+		File.open(owner_path, 'w'){|f| f.write(owner)}
+	end 
+
 	def add_entry(current)
 		entry_hex = generate_random_hex
 		new_entry = Tlog::Entity::Entry.new(entry_path(entry_hex), entry_hex)
@@ -78,6 +106,21 @@ class Tlog::Entity::Log
 
 	private
 
+	def write_log(state, points, owner)
+		File.open(points_path, 'w'){|f| f.write(points)}
+		File.open(state_path, 'w'){|f| f.write(state)}
+		File.open(owner_path, 'w'){|f| f.write(owner)}
+		File.open(hold_path, 'w+'){|f| f.write('hold')}
+		File.open(goal_path, 'w'){|f| f.write(@goal)} if @goal
+	end
+
+	def read_file(path)
+		if File.exists?(path)
+			contents = File.read(path)
+			contents.strip
+		end
+	end
+
 	def head_hex_value
 		if File.exists?(head_path)
 			head_content = File.read(head_path)
@@ -85,6 +128,18 @@ class Tlog::Entity::Log
 		end
 	end
 
+	def points_path
+		File.join(@path, 'POINTS')
+	end
+
+	def state_path
+		File.join(@path, 'STATE')
+	end
+
+	def owner_path
+		File.join(@path, 'OWNER')
+	end
+
 	def goal_path
 		File.join(@path, 'GOAL')
 	end

data/lib/tlog/error.rb

@@ -3,4 +3,10 @@ class Tlog::Error::CommandNotFound < StandardError
 end
 
 class Tlog::Error::CommandInvalid < StandardError
+end
+
+class Tlog::Error::TimeLogNotFound < StandardError
+end
+
+class Tlog::Error::CheckoutInvalid < StandardError
 end

data/lib/tlog/output.rb

@@ -26,4 +26,8 @@ class Tlog::Output
 		@stdout.puts out.red
 	end
 
+	def line_blue(out)
+		@stdout.puts out.blue
+	end
+
 end

data/lib/tlog/storage/disk.rb

@@ -7,8 +7,6 @@ class Tlog::Storage::Disk
 	attr_accessor :tlog_index
 	attr_accessor :working_dir
 
-	# Class methods 'create_repo' 'all_logs', also 'create' command
-
 	def initialize(git_dir)	
 		@git = Git.open(find_repo(git_dir))
 		# Format class?
@@ -25,11 +23,21 @@ class Tlog::Storage::Disk
 		end
 	end
 
-	def create_log(log)
+	def checkout_log(log)
+		File.open(checkout_path, 'w'){|f| f.write(log.name)}
+		git.add
+		git.commit("Checking out time log '#{log.name}'")
+	end
+
+	def checkout_value
+		read_file(checkout_path) if File.exists?(checkout_path)
+	end
+
+	def create_log(log, options = {})
 		log.path = log_path(log.name)
-		if log.create
+		if log.create(options)
 			git.add
-			git.commit("Created log #{log.name}")
+			git.commit("Created log '#{log.name}'")
 			true
 		else
 			false
@@ -38,14 +46,13 @@ class Tlog::Storage::Disk
 
 	def delete_log(log)
 		log.path = log_path(log.name)
-		if log.delete
-			delete_current(log.name)
-			git.remove(log.path, {:recursive => "-r"})
-			git.commit("Deleted log #{log.name}")
-			true
-		else
-			false
-		end
+		log.delete
+		delete_current(log.name)
+		delete_checkout(log.name)
+
+		# Recursively removes the directory that stores the time log
+		git.remove(log.path, {:recursive => "-r"})
+		git.commit("Deleted log '#{log.name}'")
 	end
 
 	def require_log(log_name)
@@ -57,7 +64,7 @@ class Tlog::Storage::Disk
 		if update_current(log.name, entry_description)
 			create_log(log) # Creates directory if it has not already been created
 			git.add
-			git.commit("Started log #{log.name}")
+			git.commit("Started log '#{log.name}'")
 			true
 		else
 			false
@@ -65,23 +72,37 @@ class Tlog::Storage::Disk
 	end
 
 	def stop_log(log)
-		if Dir.exists?(current_path)
+		if Dir.exists?(current_path) and log.name == checkout_value
 			current_hash = { 
 				:name => current_log_name,
 				:start_time => current_start_time,
 				:description => current_entry_description,
-				:owner => cur_entry_owner
 			}
 			delete_current(current_hash[:name])
 			log.add_entry(current_hash)
 			git.add
-			git.commit("Stopped log #{log.name}")
+			git.commit("Stopped log '#{log.name}'")
 			true
 		else
 			false
 		end
 	end
 
+	def change_log_state(log, new_state)
+		log.path = log_path(log.name)
+		log.update_state(new_state)
+	end
+
+	def change_log_points(log, new_points_value)
+		log.path = log_path(log.name)
+		log.update_points(new_points_value)
+	end
+
+	def change_log_owner(log, new_owner)
+		log.path = log_path(log.name)
+		log.update_owner(new_owner)
+	end
+
 	def log_duration(log_name)
 		duration = 0
 		if current_log_name == log_name
@@ -105,6 +126,10 @@ class Tlog::Storage::Disk
 		current_start_time
 	end
 
+	def cur_user
+		git.config["user.email"].split('@').first rescue ''
+	end
+
 	def time_since_start
 		if Dir.exists?(current_path)
 			difference = Time.now - Time.parse(current_start_time)
@@ -118,10 +143,6 @@ class Tlog::Storage::Disk
 		Time.parse(current_start_time) if current_start_path
 	end
 
-	def cur_entry_owner
-		git.config["user.email"].split('@').first rescue ''
-	end
-
 	def cur_entry_description
 		current_entry_description
 	end
@@ -190,17 +211,27 @@ class Tlog::Storage::Disk
 		end
 	end
 
-	def delete_current(log_name) # Change this method name or add one
+	def delete_current(log_name)
 		if Dir.exists?(current_path)
 			if current_log_name == log_name
 				FileUtils.rm_rf(current_path)
-				git.remove(current_path, {:recursive => 'r'})
+				#git.remove(current_path, {:recursive => 'r'})
 			end
 		else
 			false
 		end
 	end	
 
+	def delete_checkout(log_name)
+		if File.exists?(checkout_path)
+			if checkout_value == log_name
+				FileUtils.rm(checkout_path)
+			end
+		else
+			fals
+		end
+	end 
+
 	def write_to_current(log_name, entry_description)
 		# Create a current object, with a "read" method
 		File.open(current_name_path, 'w'){ |f| f.write(log_name)} 
@@ -255,6 +286,10 @@ class Tlog::Storage::Disk
 		File.expand_path(File.join('tasks'))
 	end
 
+	def checkout_path
+		File.join(logs_path, 'CHECKOUT');
+	end
+
 	def current_path
 		File.expand_path(File.join('current'))
 	end

data/tlog.gemspec

@@ -2,13 +2,13 @@
 Gem::Specification.new do |spec|
 
   spec.name         = "tlog"
-  spec.version      = "0.0.8"
-  spec.date         = "2013-05-27"
+  spec.version      = "0.0.9"
+  spec.date         = "2013-06-02"
 
   spec.required_ruby_version = ">=1.9.3"
 
   spec.summary      = "CLI Project Time Logger"
-  spec.description  = "tlog is a git-based command-line time logger that keeps track the time you've spend on different parts of a project"
+  spec.description  = "tlog is a distributed project time and ticket tracker"
   spec.license      = "GPL-2"
 
   spec.add_dependency("commander", "4.0")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tlog
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Chris Wendel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-27 00:00:00.000000000 Z
+date: 2013-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -80,8 +80,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.5.8
-description: tlog is a git-based command-line time logger that keeps track the time
-  you've spend on different parts of a project
+description: tlog is a distributed project time and ticket tracker
 email: chriwend@umich.edu
 executables:
 - tlog
@@ -97,13 +96,18 @@ files:
 - lib/tlog/application.rb
 - lib/tlog/command.rb
 - lib/tlog/command/active.rb
+- lib/tlog/command/checkout.rb
 - lib/tlog/command/create.rb
 - lib/tlog/command/delete.rb
 - lib/tlog/command/display.rb
+- lib/tlog/command/help.rb
 - lib/tlog/command/init.rb
+- lib/tlog/command/owner.rb
+- lib/tlog/command/points.rb
 - lib/tlog/command/start.rb
+- lib/tlog/command/state.rb
 - lib/tlog/command/stop.rb
-- lib/tlog/command/test.rb
+- lib/tlog/command_suite.rb
 - lib/tlog/entity/active_log.rb
 - lib/tlog/entity/entry.rb
 - lib/tlog/entity/log.rb

data/lib/tlog/command/test.rb

@@ -1,32 +0,0 @@
-
-class Tlog::Command::Test < Tlog::Command
-
-	def name
-		"test"
-	end
-
-	def execute(input,output)
-		output.line("execute on test called")
-		if input.args[0].nil?
-			output.line("args at 0 was nil")
-		elsif input.args[1].nil?
-			arg1 = input.args.shift
-			output.line("arg at 0 was #{arg1}")
-		else
-			arg1 = input.args.shift
-			arg2 = input.args.shift
-			output.line("arg at 0 was #{arg1}")
-			output.line("arg at 1 was #{arg2}")	
-			raise Tlog::Error::CommandInvalid, "Command invalid"	
-		end
-	end
-
-	def options(parser, options)
-		parser.banner = "usage: tlog test <project>"
-	end
-
-	private
-
-
-
-end