tlog 0.0.1

data/lib/tlog/command/display.rb

@@ -0,0 +1,144 @@
+
+class Tlog::Command::Display < Tlog::Command
+
+	def name
+		"display"
+	end
+
+	def execute(input, output)
+		raise Tlog::Error::CommandInvalid, "Logging invalid" unless display(input.args[0], input.options[:length], output)
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog log <log_name>"
+
+		parser.on("-l", "--length <length_threshold>") do |length|
+			options[:length] = length
+		end
+	end
+
+	private
+
+	def display(log_name, length_threshold, output)
+		storage.in_branch do |wd|
+			if log_name
+				display_log(log_name, length_threshold, output)
+			else
+				display_all(length_threshold, output)
+			end 
+		end
+	end
+
+	def display_log(log_name, length_threshold, output)
+		log = storage.require_log(log_name)
+		log_length = log.goal_length
+		entries = log.entries
+		if storage.start_time_string && is_current_log_name?(log_name)
+			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_header(output)
+		print_current(log_name, log_length, start_time, output)
+		display_entries(entries, output) if entries
+		print_footer(log, log_length, output)
+	end
+
+	def display_all(length_threshold, output)
+		storage.all_log_dirs.each do |log_path|
+			log_basename = log_path.basename.to_s
+			display_log(log_basename, length_threshold, output)
+		end
+	end
+
+	def display_entries(entries, output)
+		if entries.size > 0
+			entries.each do |entry|
+				out_str = "\t%-4s   %16s  %14s   %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)
+			end
+		end
+	end
+
+	def print_footer(log, log_length, output)
+		output.line "-" * 100
+		print_total(log, output)
+		print_time_left(log, output)
+	end
+
+	def print_header(output)
+		output.line("\tStart               End                    Duration        Owner          Description")
+	end 
+
+	def print_total(log, output)
+		#output.line("-") * 52
+		duration = log.duration
+		if storage.current_log_name == log.name
+			duration += storage.time_since_start
+		end
+		output.line("\tTotal%45s " % seconds_format.duration(duration))
+	end
+
+	def print_log_name(log_name, output)
+		output.line_yellow("Log: #{log_name}")
+	end
+
+	def print_time_left(log, output)
+		if log.goal
+			log_goal = log.goal
+			if (storage.current_log_name == log.name)
+				current_time = Time.now - storage.cur_start_time
+				log_goal -= current_time.to_i
+			end
+			log_goal = 0 if log_goal < 0
+			output.line_red("\tTime left: %39s" % seconds_format.duration(log_goal)) 
+		end
+	end
+
+	#should be added to entries array, not its own seperate thing
+	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" % [
+				date_time_format.timestamp(current_start_time),
+				nil,
+				formatted_length,
+				storage.cur_entry_owner,
+				storage.cur_entry_description, 
+			]
+			output.line(out_str)
+			storage.time_since_start
+		end
+	end
+
+	def length_exceeds_threshold?(log_length, length_threshold)
+		if length_threshold and log_length
+			length_threshold = ChronicDuration.parse(length_threshold)
+			if log_length - length_threshold > 0
+				true
+			else
+				false
+			end
+		else
+			false
+		end
+	end
+
+	def update_log_length(log_length)
+		log_length - storage.time_since_start if log_length
+	end
+
+	def is_current_log_name?(log_name)
+		if storage.current_log_name == log_name
+			true
+		else
+			false
+		end
+	end
+end

data/lib/tlog/command/init.rb

@@ -0,0 +1,34 @@
+
+class Tlog::Command::Init < Tlog::Command
+
+	def name
+		"init"
+	end
+
+	def execute(input,output)
+		if input.args[0].nil?
+			raise Tlog::Error::CommandInvalid, "Project already initialized" unless @storage.init_project
+		else
+			raise Tlog::Error::CommandInvalid, "Command invalid"	
+		end
+		#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
+
+		#@storage.init_project
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog init" 
+	end
+
+	private
+
+end

data/lib/tlog/command/start.rb

@@ -0,0 +1,31 @@
+
+class Tlog::Command::Start < Tlog::Command
+
+	def name 
+		"start"
+	end 
+
+	def execute(input, output)
+		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
+		start(input.args[0], input.options[:description])
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog start <log_name>"
+
+    	parser.on("-d", "--description <description>") do |description|
+    		options[:description] = description
+    	end
+	end
+
+	private
+
+	def start(log_name, 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)
+		end
+	end
+end

data/lib/tlog/command/stop.rb

@@ -0,0 +1,25 @@
+class Tlog::Command::Stop < Tlog::Command
+
+	def name 
+		"stop"
+	end 
+
+	def execute(input, output)
+		raise Tlog::Error::CommandInvalid, "Must specify log name" unless input.args[0]
+		stop(input.args[0])
+	end
+
+	def options(parser, options)
+		parser.banner = "usage: tlog stop <log_name>"
+	end
+
+	private
+
+	def stop(log_name)
+		storage.in_branch do |wd|
+			log = storage.require_log(log_name)
+			storage.stop_log(log)
+		end
+	end
+
+end

data/lib/tlog/command/test.rb

@@ -0,0 +1,32 @@
+
+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

data/lib/tlog/command.rb

@@ -0,0 +1,14 @@
+class Tlog::Command
+
+	attr_accessor :storage
+	attr_accessor :seconds_format
+	attr_accessor :date_time_format
+
+	def execute(input, output)
+		raise NotImplementedError
+	end
+
+	def options(parser, options)
+	end
+
+end

data/lib/tlog/entity/active_log.rb

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

data/lib/tlog/entity/entry.rb

@@ -0,0 +1,90 @@
+
+class Tlog::Entity::Entry
+
+	attr_accessor :hex
+	attr_accessor :path
+
+	def initialize(path, hex)
+		@path = path
+		@hex = hex 
+	end
+
+	def length
+		time_difference if time[:start] && time[:end]
+	end
+
+	def create(parent, current)
+		FileUtils.mkdir_p(path)
+		time_log = current[:start_time].to_s + " " + Time.now.to_s
+		write_file(parent_path, parent)
+		write_file(time_path, time_log.strip)
+		write_file(description_path, current[:description])
+		write_file(owner_path, current[:owner])
+	end
+
+	def parent_hex
+		read_file(parent_path)
+	end
+
+	def time
+		time_hash = {}
+		start_time_string = ""
+		end_time_string = ""
+		time_contents = read_file(time_path)
+		return time_hash unless time_contents
+		split_contents = time_contents.split(" ", 6)
+		for i in 0..2
+			start_time_string += split_contents[i] + " "
+		end
+		for i in 3..5
+			end_time_string += split_contents[i] + " "
+		end
+		time_hash[:start] = Time.parse(start_time_string)
+		time_hash[:end] = Time.parse(end_time_string)
+		return time_hash
+	end
+
+	def description
+		read_file(description_path)
+	end
+
+	def owner 
+		read_file(owner_path)
+	end
+
+	private
+
+	def write_file(path, content)
+		File.open(path, 'w'){ |f| f.write(content)}
+	end
+
+	def read_file(path)
+		if File.exists?(path)
+			contents = File.read(path)
+			contents.strip
+		end
+	end
+
+	def time_difference
+		time_hash = time
+		difference = time_hash[:end] - time_hash[:start]
+		difference.to_i
+	end
+
+	def parent_path
+		File.join(@path, 'PARENT')
+	end
+
+	def time_path
+		File.join(@path, 'TIME')
+	end
+
+	def description_path
+		File.join(@path, 'DESCRIPTION')
+	end
+
+	def owner_path
+		File.join(@path, 'OWNER')
+	end
+
+end

data/lib/tlog/entity/log.rb

@@ -0,0 +1,102 @@
+
+class Tlog::Entity::Log
+
+	attr_accessor :name
+	attr_accessor :goal
+	attr_accessor :entries
+	attr_accessor :path
+
+	def initialize(log_path = nil)
+		@entries = []
+		if log_path
+			@name = log_path.basename.to_s
+			@path = log_path
+			@goal = goal_length
+		end
+	end
+
+	def goal_length
+		if File.exists?(goal_path)
+			contents = File.read(goal_path)
+			contents.strip
+			contents.to_i
+		end
+	end
+	
+
+	def entries
+		log_entries = []
+		hex_value = head_hex_value
+		return log_entries unless hex_value
+		begin
+			entry = Tlog::Entity::Entry.new(entry_path(hex_value), hex_value)
+			hex_value = entry.parent_hex
+			log_entries.push(entry)
+		end until hex_value == "none"
+		return log_entries
+	end
+
+	def duration
+		dur = 0
+		entries.each do |entry|
+			dur += entry.length
+		end
+		dur
+	end
+
+	def create
+		unless Dir.exists?(@path)
+			FileUtils.mkdir_p(@path)
+			File.open(goal_path, 'w'){|f| f.write(@goal)} if @goal
+			true
+		end
+	end
+
+	def add_entry(current)
+		entry_hex = generate_random_hex
+		new_entry = Tlog::Entity::Entry.new(entry_path(entry_hex), entry_hex)
+		head_hex_value ? parent_hex = head_hex_value : parent_hex = "none"
+
+		update_head(entry_hex)
+		new_entry.create(parent_hex, current)
+		update_goal(new_entry.length) if goal_length
+	end
+
+	def update_head(entry_hex)
+		File.open(head_path, 'w'){|f| f.write(entry_hex)}
+	end
+
+	def update_goal(entry_length)
+		new_length = goal_length - entry_length
+		File.open(goal_path, 'w'){|f| f.write(new_length)}
+	end
+
+	def delete
+		FileUtils.rm_rf(@path) if Dir.exists?(@path)
+	end
+
+	private
+
+	def head_hex_value
+		if File.exists?(head_path)
+			head_content = File.read(head_path)
+			head_content.strip if head_content
+		end
+	end
+
+	def goal_path
+		File.join(@path, 'GOAL')
+	end
+
+	def head_path
+		File.join(@path, 'HEAD')
+	end
+
+	def entry_path(hex)
+		File.join(@path, hex)
+	end
+
+	def generate_random_hex
+		SecureRandom.hex(13)
+	end 
+end

data/lib/tlog/error.rb

@@ -0,0 +1,6 @@
+
+class Tlog::Error::CommandNotFound < StandardError
+end
+
+class Tlog::Error::CommandInvalid < StandardError
+end

data/lib/tlog/format/date_time.rb

@@ -0,0 +1,7 @@
+class Tlog::Format::DateTime
+
+	def self.timestamp(gmt_time)
+		gmt_time.strftime("%B %d, %I:%M%p")
+	end
+
+end

data/lib/tlog/format/seconds.rb

@@ -0,0 +1,13 @@
+class Tlog::Format::Seconds
+
+	def self.duration(total_seconds)
+		output = ""
+		total_seconds ||= 0
+		total_seconds = total_seconds.to_i
+		mm, ss = total_seconds.divmod(60)
+		hh, mm = mm.divmod(60)
+		output = "%2s:%02d:%02d" % [hh, mm, ss]
+		return output
+	end
+
+end

data/lib/tlog/input.rb

@@ -0,0 +1,10 @@
+
+class Tlog::Input
+	attr_accessor :args
+	attr_accessor :options
+
+	def initialize(args=[])
+		@args = args
+		@options = {}
+	end
+end

data/lib/tlog/output.rb

@@ -0,0 +1,29 @@
+require 'colorize'
+class Tlog::Output
+
+	attr_accessor :stdout
+	attr_accessor :stderr
+
+	def initialize(stdout,stderr)
+		@stdout = stdout
+		@stderr = stderr
+	end
+
+	def error(err)
+		@stderr.puts err
+	end
+
+	def line(out)
+		@stdout.puts out
+		true
+	end
+
+	def line_yellow(out)
+		@stdout.puts out.yellow
+	end
+
+	def line_red(out)
+		@stdout.puts out.red
+	end
+
+end