timr 0.3.0 → 0.4.0

data/lib/timr/progressbar.rb

@@ -0,0 +1,41 @@
+
+module TheFox
+	module Timr
+		
+		# See [ruby-progressbar Issue #131](https://github.com/jfelchner/ruby-progressbar/issues/131).
+		class ProgressBar
+			
+			def initialize(options = Hash.new)
+				@total = options.fetch(:total, 100)
+				@progress = options.fetch(:progress, 0)
+				@length = options.fetch(:length, 10)
+				@progress_mark = options.fetch(:progress_mark, ?#)
+				@remainder_mark = options.fetch(:remainder_mark, ?-)
+			end
+			
+			# Render ProgressBar as String.
+			def render(progress = nil)
+				if progress
+					@progress = progress
+				end
+				
+				progress_f = @progress.to_f / @total.to_f
+				if progress_f > 1.0
+					progress_f = 1.0
+				end
+				
+				progress_f = @length.to_f * progress_f
+				
+				progress_s = @progress_mark * progress_f
+				
+				remain_l = @length - progress_s.length
+				
+				remain_s = @remainder_mark * remain_l
+				
+				'%s%s' % [progress_s, remain_s]
+			end
+			
+		end # class ProgressBar
+		
+	end # module Timr
+end # module TheFox

data/lib/timr/simple_opt_parser.rb

@@ -0,0 +1,230 @@
+
+module TheFox
+	module Timr
+		
+		# Simple Option Parser
+		# 
+		# Because OptParse sucks. Parsing arguments should be easy. :(
+		# 
+		# Covered Usecases
+		# 
+		# - -a
+		# - --all
+		# - -a --all
+		# - -a -b val
+		# - -a -b val cmd
+		# - -a -b val cmd1 cmd2
+		# - -a -b val1 val2
+		# - -a -b val1 val2 cmd1 cmd2
+		# - -ab
+		# - -ab val
+		# 
+		# ### Usage
+		# ```
+		# optparser = SimpleOptParser.new
+		# optparser.register_option(['-a'])
+		# optparser.register_option(['-b'])
+		# optparser.register_option(['-c'], 1)
+		# opts = optparser.parse('-a -b -c val')
+		# ```
+		class SimpleOptParser
+			
+			# Parsed Options (+Commands)
+			attr_reader :options
+			
+			# Not Recognized Options
+			attr_reader :unknown_options
+			
+			def initialize
+				#  -a   => 0
+				# --all => 0
+				#  -b   => 1
+				@valid_options = Hash.new
+				
+				# a   => 0
+				# all => 0
+				# b   => 1
+				# @valid_options_without_prefix = Hash.new
+				
+				# Parsed Options (+Commands)
+				@options = Array.new
+				
+				# Not Recognized Options
+				@unknown_options = Array.new
+			end
+			
+			# `aliases` (Array)
+			#
+			# `number_values`
+			# 
+			# -  0 = no value, just a switch
+			# - -1 = unlimited
+			# -  n = n values
+			def register_option(aliases, number_values = 0)
+				aliases.each do |ali|
+					@valid_options[ali] = number_values
+					
+					# if ali[0] == '-'
+					# 	if ali[1] == '-'
+					# 		# --arg
+					# 		# Cut the two first characters.
+					# 		@valid_options_without_prefix[ali[2..-1]] = number_values
+					# 	else
+					# 		# -a
+					# 		# Cut only the first character.
+					# 		@valid_options_without_prefix[ali[1..-1]] = number_values
+					# 	end
+					# end
+				end
+			end
+			
+			# `args` (Array|String)
+			def parse(args)
+				# Reset previous options.
+				@options = []
+				
+				if args.is_a?(Array)
+					pre_argv = args
+				else
+					pre_argv = args.split(' ')
+				end
+				
+				argv = Array.new
+				
+				# Pre-process Special Argument (Compact)
+				# For example '-abcd' is '-a -b -c -d'.
+				pre_argv.each do |arg|
+					if arg[0] == '-'
+						if arg[1] == '-'
+							# Normal --arg
+							argv << arg
+						else
+							if arg.length > 2
+								# Special -ab
+								arg = arg[1..-1]
+								
+								# Add each single argument separate.
+								# Array ['-abc'] will become ['-a', '-b', '-c'].
+								arg.length.times do |n|
+									argv << "-#{arg[n]}"
+								end
+							else
+								# Normal -a
+								argv << arg
+							end
+						end
+					else
+						# Commands, Values, etc
+						argv << arg
+					end
+				end
+				
+				loop_c = 0 # Limit the loop.
+				while argv.length > 0 && loop_c < 1024
+					loop_c += 1
+					
+					arg = argv.shift
+					
+					if arg[0] == '-'
+						if @valid_options[arg]
+							# Recognized Argument
+							
+							number_values = @valid_options[arg]
+							
+							if number_values == 0
+								# No values. Like Command.
+								@options << [arg]
+							elsif number_values == -1
+								# Eat all the arguments. Nom nom nom.
+								arg_values = []
+								sub_loop_c = 0 # Limit the loop.
+								while argv.length > 0 && sub_loop_c < 1024
+									sub_loop_c += 1
+									
+									arg = argv.shift
+									
+									# When reaching the end.
+									unless arg
+										break
+									end
+									
+									arg_values << arg
+								end
+								@options << arg_values
+							else
+								# n values.
+								
+								arg_values = []
+								sub_loop_c = 0 # Limit the loop.
+								while argv.length > 0 && sub_loop_c < number_values && sub_loop_c < 1024
+									sub_loop_c += 1
+									
+									val = argv.shift
+									
+									# When reaching the end.
+									unless val
+										raise ArgumentError, "SimpleOptParser: Argument '#{arg}' expects #{number_values} value(s). Found #{sub_loop_c}."
+									end
+									
+									if @valid_options[val]
+										raise ArgumentError, "SimpleOptParser: Argument '#{arg}' expects #{number_values} value(s). Found another Argument '#{val}'."
+									end
+									
+									arg_values << val
+								end
+								
+								if arg_values.length != number_values
+									raise ArgumentError, "SimpleOptParser: Argument '#{arg}' expects #{number_values} value(s), #{arg_values.length} given."
+								end
+								
+								arg_values.unshift(arg)
+								@options << arg_values
+							end
+						else
+							# Unknown Arguments
+							# '-ab' arguments will be processed in pre_argv.
+							@unknown_options << arg
+						end
+					else
+						# Command
+						@options << [arg]
+					end
+				end
+				
+				@options
+			end
+			
+			# Do not re-parse. Verify an already parsed array.
+			def verify(opts)
+				opts.each do |opt_ar|
+					arg = opt_ar.first
+					
+					number_values = @valid_options[arg]
+					if number_values.nil?
+						# Unknown Arguments
+					else
+						# Argument is valid.
+						
+						# Check length.
+						if number_values == 0
+							if opt_ar.length > 0
+								raise ArgumentError, "SimpleOptParser: Argument '#{arg}' expects no values, #{opt_ar.length} given."
+							end
+						elsif number_values == -1
+							# Always OK. Keep eating, Pacman.
+						else
+							if number_values != opt_ar.length
+								raise ArgumentError, "SimpleOptParser: Argument '#{arg}' expects #{number_values} value(s), #{opt_ar.length} given."
+							end
+						end
+					end
+				end
+				
+				true
+			end
+			
+		end # class SimpleOptParser
+	
+	end # module Timr
+end # module TheFox
+

data/lib/timr/status.rb

@@ -0,0 +1,70 @@
+
+require 'term/ansicolor'
+
+module TheFox
+	module Timr
+		
+		# Used as [Task](rdoc-ref:TheFox::Timr::Model::Task) and [Track](rdoc-ref:TheFox::Timr::Model::Track) Status.
+		# 
+		# - `R`  running
+		# - `S`  stopped
+		# - `P`  paused. It's actually stopped but with an additional flag.
+		# - `-` (dash) not started
+		# - `U`  unknown
+		class Status
+			
+			include Term::ANSIColor
+			
+			# Source Data
+			attr_reader :short_status
+			
+			# Resolved by `short_status`. See `set_long_status` method.
+			attr_reader :long_status
+			
+			def initialize(short_status)
+				@short_status = short_status
+				
+				@long_status = nil
+				set_long_status
+			end
+			
+			# Use `term/ansicolor` to colorize the Long Status.
+			def colorized
+				case @short_status
+				when ?R
+					green(@long_status)
+				when ?S
+					red(@long_status)
+				else
+					@long_status
+				end
+			end
+			
+			# To String
+			def to_s
+				long_status
+			end
+			
+			private
+			
+			def set_long_status
+				@long_status = case @short_status
+					when ?-
+						'not started'
+					when ?R
+						'running'
+					when ?S
+						'stopped'
+					when ?P
+						'paused'
+					when ?U
+						'unknown'
+					else
+						'unknown'
+					end
+			end
+			
+		end # class Status
+		
+	end # module Timr
+end # module TheFox

data/lib/timr/table.rb

@@ -0,0 +1,88 @@
+
+module TheFox
+	module Timr
+		
+		class Table
+			
+			# Holds all rows.
+			attr_reader :rows
+			
+			def initialize(options = Hash.new)
+				@headings = options.fetch(:headings, Array.new)
+				
+				@rows = Array.new
+			end
+			
+			# Append a row.
+			def <<(row)
+				col_n = 0
+				row.each do |col|
+					header = @headings[col_n]
+					if header
+						header[:format] ||= '%s'
+						header[:label] ||= ''
+						unless header.has_key?(:empty)
+							header[:empty] = true
+						end
+						header[:max_length] ||= 0
+						header[:padding_left] ||= ''
+						header[:padding_right] ||= ''
+					else
+						header = {
+							:format => '%s',
+							:label => '',
+							:empty => true,
+							:max_length => 0,
+							:padding_left => '',
+							:padding_right => '',
+						}
+					end
+					
+					unless col.nil?
+						if header[:empty]
+							header[:empty] = false
+						end
+						col_s = col.to_s
+						if col_s.length > header[:max_length]
+							header[:max_length] = (header[:format] % [col_s]).length + header[:padding_left].length + header[:padding_right].length
+						end
+					end
+					
+					col_n += 1
+				end
+				@rows << row
+			end
+			
+			# Render Table to String.
+			def to_s
+				s = ''
+				
+				s << @headings.map{ |header|
+					unless header[:empty]
+						"%s#{header[:format]}%s" % [header[:padding_left], header[:label], header[:padding_right]]
+					end
+				}.select{ |ts| !ts.nil? }.join(' ')
+				s << "\n"
+				
+				@rows.each do |row|
+					col_n = 0
+					columns = []
+					row.each do |col|
+						header = @headings[col_n]
+						unless header[:empty]
+							col_s = "%s#{header[:format]}%s" % [header[:padding_left], col, header[:padding_right]]
+							
+							columns << col_s
+						end
+						col_n += 1
+					end
+					s << columns.join(' ') << "\n"
+				end
+				
+				s
+			end
+			
+		end # class Task
+		
+	end # module Timr
+end #module TheFox

data/lib/timr/timr.rb

@@ -1,659 +1,601 @@
 
-require 'curses'
-require 'time'
-require 'fileutils'
-require 'yaml/store'
-require 'thefox-ext'
+require 'pathname'
 
 module TheFox
 	module Timr
 		
+		# Core Class
+		# 
+		# Loads and saves Models to files. Tasks are loaded to `@tasks`.
+		# 
+		# Holds the [Stack](rdoc-ref:TheFox::Timr::Model::Stack) instance. Responsible to call Stack methods.
 		class Timr
 			
-			#include Curses
+			include Model
+			include Error
 			
-			def initialize(base_dir_path, config_path = nil)
-				@base_dir_path = File.expand_path(base_dir_path)
-				@base_dir_name = File.basename(@base_dir_path)
-				@data_dir_path = "#{@base_dir_path}/data"
-				@config_path = config_path
-				
-				puts "base:   #{@base_dir_path}"
-				puts "name:   #{@base_dir_name}"
-				puts "data:   #{@data_dir_path}"
-				puts "config: #{@config_path}"
-				
-				@stack = Stack.new
-				@tasks = {}
-				@last_write = nil
-				@config = {
-					'clock' => {
-						'default' => '%F %R',
-						'large' => '%F %T',
-						'short' => '%R',
-					},
-				}
-				#@ui_window_refresh_last = nil
-				#@ui_status_line_last = nil
-				
-				config_read
-				init_dirs
-				tasks_load
-				
-				@window = nil
-				@window_help = HelpWindow.new
-				@window_test = TestWindow.new
-				
-				@window_tasks = TasksWindow.new(@tasks)
-				@window_timeline = TimelineWindow.new(@tasks)
-			end
+			# ForeignIdDb instance.
+			attr_reader :foreign_id_db
 			
-			def config_read(path = @config_path)
-				if !path.nil? && File.exist?(path)
-					content = YAML::load_file(path)
-					if content
-						@config.merge_recursive!(content)
-					end
-				end
-			end
+			# Stack instance.
+			attr_reader :stack
 			
-			def init_dirs
-				if !Dir.exist?(@base_dir_path)
-					FileUtils.mkdir_p(@base_dir_path)
-				end
-				if !Dir.exist?(@data_dir_path)
-					FileUtils.mkdir_p(@data_dir_path)
+			def initialize(cwd)
+				# Current Working Directory
+				case cwd
+				when String
+					@cwd = Pathname.new(cwd)
+				else
+					@cwd = cwd
 				end
-			end
-			
-			def tasks_load
-				Dir.chdir(@data_dir_path) do
-					Dir['task_*.yml'].each do |file_name|
-						#puts "file: '#{file_name}'"
-						task = Task.new(file_name)
-						@tasks[task.id] = task
-					end
+				
+				if @cwd && !@cwd.exist?
+					puts "Initialize Timr in #{@cwd}"
+					@cwd.mkpath
 				end
-			end
-			
-			def tasks_stop
-				@tasks.each do |task_id, task|
-					task.stop
+				
+				@config = Config.new
+				@config.file_path = Pathname.new('config.yml').expand_path(@cwd)
+				if @config.file_path.exist?
+					@config.load_from_file
+				else
+					#@config.save_to_file
+					@config.save_to_file(nil, true)
 				end
-			end
-			
-			def tasks_save(print_status = false)
-				@last_write = Time.now
-				if print_status
-					ui_status_text("Store files ... #{Time.now.strftime('%T')}")
+				
+				@foreign_id_db = ForeignIdDb.new
+				@foreign_id_db.file_path = Pathname.new('foreign_id_db.yml').expand_path(@cwd)
+				if @foreign_id_db.file_path.exist?
+					@foreign_id_db.load_from_file
 				end
-				Dir.chdir(@data_dir_path) do
-					@tasks.each do |task_id, task|
-						task.save_to_file('.')
-					end
+				
+				@tasks_path = Pathname.new('tasks').expand_path(@cwd)
+				unless @tasks_path.exist?
+					@tasks_path.mkpath
 				end
-				if print_status
-					ui_status_text("Files stored. #{Time.now.strftime('%T')}")
+				
+				# Holds all loaded Tasks.
+				@tasks = Hash.new
+				
+				# Stack Path
+				stack_path = Pathname.new('stack.yml').expand_path(@cwd)
+				
+				# Stack
+				@stack = Stack.new
+				@stack.timr = self
+				@stack.file_path = stack_path
+				if stack_path.exist?
+					@stack.load_from_file
 				end
 			end
 			
-			def ui_init_curses
-				Curses.noecho
-				Curses.timeout = TIMEOUT
-				Curses.curs_set(0)
-				Curses.init_screen
-				Curses.start_color
-				Curses.use_default_colors
-				Curses.crmode
-				Curses.stdscr.keypad(true)
-				
-				Curses.init_pair(Curses::COLOR_BLUE, Curses::COLOR_WHITE, Curses::COLOR_BLUE)
-				Curses.init_pair(Curses::COLOR_RED, Curses::COLOR_WHITE, Curses::COLOR_RED)
-				Curses.init_pair(Curses::COLOR_GREEN, Curses::COLOR_BLACK, Curses::COLOR_GREEN)
-			end
-			
-			def ui_title_line
-				title = "#{NAME} #{VERSION} -- #{@base_dir_name}"
-				if Curses.cols <= title.length + 1
-					title = "#{NAME} #{VERSION}"
-					if Curses.cols <= title.length + 1
-						title = NAME
+			# Removes all previous [Tracks](rdoc-ref:TheFox::Timr::Model::Track) and starts a new one.
+			# 
+			# Options:
+			# 
+			# - `:foreign_id` (String)
+			# - `:task_id` (String)
+			# - `:track_id` (String)
+			def start(options = Hash.new)
+				foreign_id_opt = options.fetch(:foreign_id, nil)
+				task_id_opt = options.fetch(:task_id, nil)
+				track_id_opt = options.fetch(:track_id, nil)
+				
+				# Get current Track from Stack.
+				old_track = @stack.current_track
+				
+				# Stop current running Track.
+				if old_track
+					# Get Task from Track.
+					old_task = old_track.task
+					unless old_task
+						raise TrackError, "Track #{old_track.short_id} has no Task."
 					end
+					
+					# Stop Task
+					old_task.stop
+					
+					# Save Task
+					old_task.save_to_file
+					
+					old_task = nil
 				end
-				rest = Curses.cols - title.length - COL
 				
-				Curses.setpos(0, 0)
-				Curses.attron(Curses.color_pair(Curses::COLOR_BLUE) | Curses::A_BOLD) do
-					Curses.addstr(' ' * COL + title + ' ' * rest)
-				end
-			end
-			
-			# This is the line on the bottom of the screen.
-			def ui_status_text(text = nil, attrn = Curses::A_NORMAL)
-				line_nr = Curses.lines - 1
-				
-				Curses.setpos(line_nr, 0)
-				Curses.clrtoeol
-				if !text.nil?
-					Curses.setpos(line_nr, COL)
-					Curses.attron(attrn) do
-						Curses.addstr(text)
+				if task_id_opt
+					task = get_task_by_id(task_id_opt)
+					
+					if foreign_id_opt
+						# Throws exception when Foreign ID already exists in DB.
+						# Break before new Track creation.
+						@foreign_id_db.add_task(task, foreign_id_opt)
+						@foreign_id_db.save_to_file
 					end
-				end
-				Curses.refresh
-			end
-			
-			def ui_status_text_error(text)
-				ui_status_text(text, Curses.color_pair(Curses::COLOR_RED) | Curses::A_BOLD)
-			end
-			
-			# Use the Status Text line to get an input from user.
-			def ui_status_input(text)
-				Curses.echo
-				Curses.timeout = -1
-				Curses.curs_set(1)
-				
-				ui_status_text(text)
-				
-				input = ''
-				abort = false
-				loop do
-					key_pressed = Curses.getch
-					case key_pressed
-					when 27
-						abort = true
-						break
-					when Curses::Key::BACKSPACE
-						if input.length > 0
-							Curses.stdscr.delch
-							input = input[0..-2]
+					
+					track = task.start(options)
+					
+					task.save_to_file
+					
+					@stack.start(track)
+					@stack.save_to_file
+				else
+					if track_id_opt
+						# Seach Track ID the long way. Should be avoided.
+						# Searches all files.
+						
+						track = Track.find_track_by_id(@tasks_path, track_id_opt)
+						if track
+							options[:track_id] = track.id
+							
+							# Get Task from Track.
+							task = track.task
+							unless task
+								raise TrackError, "Track #{track.short_id} has no Task."
+							end
+							
+							# Start Task
+							track = task.start(options)
+							
+							# Save Task
+							task.save_to_file
+							
+							@stack.start(track)
+							@stack.save_to_file
 						end
-					when 10
-						break
-					when nil
-						# Do nothing.
-						#sleep TIMEOUT.to_f / 1000
 					else
-						input += key_pressed.to_s
+						# Create completely new Task.
+						task = Task.create_task_from_hash(options)
+						
+						if foreign_id_opt
+							# Throws exception when Foreign ID already exists in DB.
+							# Break before new Track creation.
+							@foreign_id_db.add_task(task, foreign_id_opt)
+							@foreign_id_db.save_to_file
+						end
+						
+						# Start Task
+						track = task.start(options)
+						
+						# Task Path
+						task_file_path = BasicModel.create_path_by_id(@tasks_path, task.id)
+						
+						# Save Track to file.
+						task.save_to_file(task_file_path)
+						
+						@stack.start(track)
+						@stack.save_to_file
 					end
 				end
-				if abort
-					input = nil
-				end
 				
-				Curses.noecho
-				Curses.timeout = TIMEOUT
-				Curses.curs_set(0)
-				
-				input
+				track
 			end
 			
-			# The second line from the bottom:
-			# Show current Track status, Track Time Difference, Task Time Total.
-			def ui_status_line(init = false)
-				line_nr = Curses.lines - 2
+			# Stops the current running [Track](rdoc-ref:TheFox::Timr::Model::Track) and removes it from the Stack.
+			def stop(options = Hash.new)
+				# Get current Track from Stack.
+				track = @stack.current_track
+				unless track
+					return
+				end
 				
-				status_s = ''
-				track_begin_time_s = ''
+				# Get Task from Track.
+				task = track.task
 				
-				run_time_track_str = ''
-				run_time_track_h = 0
-				run_time_track_m = 0
-				run_time_track_s = 0
+				# Stop Task
+				task.stop(options)
 				
-				run_time_total_str = ''
-				run_time_total_h = 0
-				run_time_total_m = 0
-				run_time_total_s = 0
+				# Save Task
+				task.save_to_file
 				
-				time_s = ''
+				@stack.stop
+				@stack.save_to_file
 				
-				stack_has_task = @stack.has_task?.freeze
-				if stack_has_task
-					status_s = @stack.task.status
-					
-					track_begin_time_s = '--:--'
-					if @stack.task.running? && @stack.task.has_track?
-						track_begin_time_s = @stack.task.track.begin_time.strftime('%R')
-					end
-					
-					run_time_track_h, run_time_track_m, run_time_track_s = @stack.task.run_time_track
-					run_time_total_h, run_time_total_m, run_time_total_s = @stack.task.run_time_total
-				else
-					status_s = TASK_NO_TASK_LOADED_CHAR
+				track
+			end
+			
+			# Stops the current running [Track](rdoc-ref:TheFox::Timr::Model::Track) but does not remove it from the Stack.
+			def pause(options = Hash.new)
+				# Get current Track from Stack.
+				track = @stack.current_track
+				unless track
+					return
 				end
 				
-				if Curses.cols > MIN_COLS
-					if stack_has_task
-						run_time_track_str = '%2d:%02d:%02d' % [run_time_track_h, run_time_track_m, run_time_track_s]
-						run_time_total_str = '%2d:%02d:%02d' % [run_time_total_h, run_time_total_m, run_time_total_s]
-					end
-					
-					time_format = @config['clock']['default']
-					if Curses.cols <= 50
-						if stack_has_task
-							run_time_track_str = '%2d:%02d' % [run_time_track_h, run_time_track_m]
-						end
-						run_time_total_str = ''
-						
-						time_format = nil
-					elsif Curses.cols <= 60
-						if stack_has_task
-							run_time_track_str = '%2d:%02d' % [run_time_track_h, run_time_track_m]
-							run_time_total_str = '%2d:%02d' % [run_time_total_h, run_time_total_m]
-						end
-						
-						time_format = @config['clock']['short']
-					elsif Curses.cols > 80
-						time_format = @config['clock']['large']
-					end
-					if !time_format.nil?
-						time_s = Time.now.strftime(time_format)
-					end
+				# Track Status
+				if track.stopped?
+					raise TrackError, "Cannot pause current Track #{track.short_id}, is not running."
 				end
 				
-				line = "#{status_s} #{track_begin_time_s} #{run_time_track_str} #{run_time_total_str}"
+				# Get Task from Track.
+				task = track.task
 				
-				rest = Curses.cols - COL - line.length - time_s.length - 1
-				line += ' ' * rest + time_s
+				# Pause Task
+				track = task.pause(options)
 				
-				Curses.attron(Curses.color_pair(Curses::COLOR_GREEN) | Curses::A_NORMAL) do
-					if init
-						Curses.setpos(line_nr, 0)
-						Curses.clrtoeol
-						Curses.addstr(' ' * Curses.cols)
-					end
-					
-					Curses.setpos(line_nr, COL)
-					Curses.addstr(line)
-				end
+				# Save Task
+				task.save_to_file
+				
+				# Do nothing on the Stack.
 				
-				Curses.refresh
+				track
 			end
 			
-			def ui_window_show(window)
-				@window = window
-				ui_window_refresh_all
+			# Continues the Top [Track](rdoc-ref:TheFox::Timr::Model::Track).
+			# 
+			# Options:
+			# 
+			# - `:track` (Track)
+			def continue(options = Hash.new)
+				# Get current Track from Stack.
+				track = @stack.current_track
+				unless track
+					return
+				end
+				options[:track] = track
+				
+				# Get Task from Track.
+				task = track.task
+				
+				# Continue Task
+				track = task.continue(options)
+				
+				# Save Task
+				task.save_to_file
+				
+				@stack.stop
+				@stack.push(track)
+				@stack.save_to_file
+				
+				track
 			end
 			
-			def ui_content_line(line_nr, text)
-				Curses.setpos(line_nr, 0)
-				Curses.clrtoeol
-				
-				rest = Curses.cols - text.length - COL
-				if rest < 0
-					rest = 0
+			# Starts a new [Track](rdoc-ref:TheFox::Timr::Model::Track) and pauses the underlying one.
+			# 
+			# Options:
+			# 
+			# - `:foreign_id` (String)
+			# - `:task_id` (String)
+			# - `:track_id` (String)
+			def push(options = Hash.new)
+				foreign_id_opt = options.fetch(:foreign_id, nil)
+				task_id_opt = options.fetch(:task_id, nil)
+				track_id_opt = options.fetch(:track_id, nil)
+				
+				# Get current Track from Stack.
+				old_track = @stack.current_track
+				
+				# Stop current running Track.
+				if old_track
+					# Get Task from Track.
+					old_task = old_track.task
+					unless old_task
+						raise TrackError, "Track #{old_track.short_id} has no Task."
+					end
+					
+					# Stop Task here because on pop we need to take the
+					# current Track from Stack instead from Task.
+					# You can push another Track from an already existing
+					# Task on the Stack. A Task can hold only one current Track.
+					old_task.stop
+					
+					# Save Task
+					old_task.save_to_file
+					
+					old_task = nil
 				end
-				out = ' ' * COL + text + ' ' * rest
 				
-				if @window.has_cursor? && line_nr == @window.cursor
-					Curses.attron(Curses.color_pair(Curses::COLOR_BLUE) | Curses::A_BOLD) do
-						Curses.addstr(out)
+				if task_id_opt
+					task = get_task_by_id(task_id_opt)
+					
+					if foreign_id_opt
+						# Throws exception when Foreign ID already exists in DB.
+						# Break before new Track creation.
+						@foreign_id_db.add_task(task, foreign_id_opt)
+						@foreign_id_db.save_to_file
 					end
+					
+					# Start Task
+					track = task.start(options)
+					
+					# Save Task
+					task.save_to_file
+					
+					@stack.push(track)
+					@stack.save_to_file
 				else
-					Curses.addstr(out)
-				end
-			end
-			
-			def ui_window_refresh_all
-				if !@window.nil?
-					content_line_nr = 1
-					@window.content_refresh
-					max_line_len = Curses.cols - 2
-					@window.page.each do |line_object|
-						line_text = line_object.to_s
+					if track_id_opt
+						# The long way. Should be avoided.
+						# Search all files.
+						
+						track = Track.find_track_by_id(@tasks_path, track_id_opt)
+						if track
+							options[:track_id] = track.id
+							
+							# Get Task from Track.
+							task = track.task
+							unless task
+								raise TrackError, "Track #{track.short_id} has no Task."
+							end
+							
+							# Start Task
+							track = task.start(options)
+							
+							# Save Task
+							task.save_to_file
+							
+							@stack.push(track)
+							@stack.save_to_file
+						end
+					else
+						# Create completely new Task.
+						task = Task.create_task_from_hash(options)
 						
-						if line_text.length > max_line_len
-							range = 0..-(line_text.length - max_line_len + 4)
-							line_text = "#{line_text[range]}..."
+						if foreign_id_opt
+							# Throws exception when Foreign ID already exists in DB.
+							# Break before new Track creation.
+							@foreign_id_db.add_task(task, foreign_id_opt)
+							@foreign_id_db.save_to_file
 						end
 						
-						ui_content_line(content_line_nr, line_text)
+						# Start Task
+						track = task.start(options)
 						
-						content_line_nr += 1
+						# Task Path
+						task_file_path = BasicModel.create_path_by_id(@tasks_path, task.id)
 						
-						# if $DEBUG
-						# 	Curses.refresh
-						# 	sleep 0.01
-						# end
-					end
-					
-					window_page_length = @window.page_length
-					content_length = ui_content_length
-					if window_page_length < content_length
-						((window_page_length + 1)..content_length).to_a.each do |rest_line_nr|
-							Curses.setpos(rest_line_nr, 0)
-							Curses.clrtoeol
-							
-							# if $DEBUG
-							# 	Curses.addstr("-- CLEAR -- #{rest_line_nr} #{Time.now.strftime('%T')}")
-							# 	Curses.refresh
-							# 	sleep 0.01
-							# end
-						end
+						# Save Track to file.
+						task.save_to_file(task_file_path)
+						
+						@stack.push(track)
+						@stack.save_to_file
 					end
 				end
 				
-				Curses.refresh
+				track
 			end
 			
-			def ui_content_length
-				Curses.lines - RESERVED_LINES - @stack.size
+			# Stops the Top [Track](rdoc-ref:TheFox::Timr::Model::Track), removes it from the [Stack](rdoc-ref:TheFox::Timr::Model::Stack) and
+			# continues the next underlying (new Top) Track.
+			def pop(options = Hash.new)
+				stop(options)
+				continue(options)
 			end
 			
-			def update_content_length
-				cl = ui_content_length
+			# Create a new [Task](rdoc-ref:TheFox::Timr::Model::Task) based on the `options` Hash. Will not be started or something else.
+			# 
+			# Uses [Task#create_task_from_hash](rdoc-ref:TheFox::Timr::Model::Task::create_task_from_hash) to create a new Task instance and [BasicModel#create_path_by_id](rdoc-ref:TheFox::Timr::Model::BasicModel.create_path_by_id) to create a new file path.
+			# 
+			# Returns the new created Task instance.
+			# 
+			# Options:
+			# 
+			# - `:foreign_id` (String)
+			def add_task(options = Hash.new)
+				foreign_id_opt = options.fetch(:foreign_id, nil)
+				
+				task = Task.create_task_from_hash(options)
+				
+				if foreign_id_opt
+					# Throws exception when Foreign ID already exists in DB.
+					# Break before Task save.
+					@foreign_id_db.add_task(task, foreign_id_opt)
+					@foreign_id_db.save_to_file
+				end
 				
-				@window_help.content_length = cl
-				@window_test.content_length = cl
-				@window_tasks.content_length = cl
-				@window_timeline.content_length = cl
-			end
-			
-			def ui_refresh_simple
-				ui_stack_lines_refresh
-				ui_window_refresh_all
+				# Task Path
+				task_file_path = BasicModel.create_path_by_id(@tasks_path, task.id)
+				
+				# Save Track to file.
+				task.save_to_file(task_file_path)
+				
+				# Leave Stack untouched.
+				
+				task
 			end
 			
-			def ui_refresh_all
-				#@ui_window_refresh_last = nil
+			# Remove a [Task](rdoc-ref:TheFox::Timr::Model::Task).
+			# 
+			# Options:
+			# 
+			# - `:task_id` (String) Can be either a internal ID (hex) or Foreign ID, because `get_task_by_id` searches also the Foreign ID DB.
+			def remove_task(options = Hash.new)
+				task_id_opt = options.fetch(:task_id, nil)
+				
+				unless task_id_opt
+					raise TaskError, 'No Task ID given.'
+				end
 				
-				update_content_length
-				ui_title_line
-				ui_status_line(true)
-				ui_refresh_simple
+				task = get_task_by_id(task_id_opt)
+				
+				@tasks.delete(task.id)
+				
+				# Get running Tracks and remove these from Stack.
+				task.tracks({:status => ?R}).each do |track_id, track|
+					@stack.remove(track)
+				end
+				@stack.save_to_file
+				
+				# Remove Task from Foreign ID DB.
+				@foreign_id_db.remove_task(task)
+				@foreign_id_db.save_to_file
+				
+				task.delete_file
+				
+				task
 			end
 			
-			def ui_stack_lines_refresh
-				line_nr = Curses.lines - (3 + (@stack.size - 1))
+			# Remove a Track.
+			# 
+			# Options:
+			# 
+			# - `:track_id` (String) 
+			def remove_track(options = Hash.new)
+				track_id_opt = options.fetch(:track_id, nil)
 				
-				Curses.attron(Curses.color_pair(Curses::COLOR_BLUE)) do
-					@stack.tasks_texts.reverse.each do |line_text|
-						rest = Curses.cols - line_text.length - COL
-						
-						Curses.setpos(line_nr, 0)
-						Curses.clrtoeol
-						Curses.addstr(' ' * COL + line_text + ' ' * rest)
-						
-						line_nr += 1
-					end
+				unless track_id_opt
+					raise TrackError, 'No Track ID given.'
+				end
+				
+				track = get_track_by_id(track_id_opt)
+				unless track
+					raise TrackError, "Track for ID '#{track_id_opt}' not found."
 				end
 				
-				Curses.refresh
+				task = track.task
+				
+				track.remove
+				
+				task.save_to_file
+				
+				# Remove Track from Stack.
+				@stack.remove(track)
+				@stack.save_to_file
+				
+				{
+					:task => task,
+					:track => track,
+				}
 			end
 			
-			def task_apply(task = nil, parent_track = nil, push = false)
-				if task.nil?
-					@stack.pop_all
+			# Find a [Task](rdoc-ref:TheFox::Timr::Model::Task) by ID (internal or foreign).
+			# 
+			# Tasks always should be loaded with this methods to check if a Task instance already exist at `@tasks`. This is like a cache.
+			# 
+			# `task_id` can be a short ID or a Foreign ID. If a Task is already loaded with full ID another search by short ID would lead to generate a new object_id. Then there would be two Tasks instances loaded for the same Task ID. The Check Cache if condition prohibits this.
+			def get_task_by_id(task_id)
+				# First search in Foreign ID DB.
+				tmp_task_id = @foreign_id_db.get_task_id(task_id)
+				if tmp_task_id
+					task_id = tmp_task_id
+				end
+				
+				task = @tasks[task_id]
+				
+				if task
+					# Take Task from cache.
 				else
-					@tasks[task.id] = task
-					if push
-						@stack.push(task, parent_track)
+					task = Task.load_task_from_file_with_id(@tasks_path, task_id)
+					
+					# Check cache.
+					if @tasks[task.id]
+						# Task already loaded.
+						task = @tasks[task.id]
 					else
-						@stack.pop_all(task, parent_track)
+						# Set new loaded Task.
+						@tasks[task.id] = task
 					end
 				end
 				
-				update_content_length
-				window_content_changed
-				ui_stack_lines_refresh
-				ui_window_refresh_all
+				task
 			end
 			
-			def task_apply_replace_stack(task, parent_track = nil)
-				if !task.nil?
-					task_apply(task, parent_track, false)
+			# Find a [Track](rdoc-ref:TheFox::Timr::Model::Track) by ID.
+			def get_track_by_id(track_id)
+				@tasks.each do |task_id, task|
+					track = task.find_track_by_id(track_id)
+					if track
+						return track
+					end
 				end
+				
+				nil
 			end
 			
-			def task_apply_stack_pop_all
-				task_apply(nil, nil, false)
+			# Get a Track by a specific Task ID and Track ID.
+			def get_track_by_task_id(task_id, track_id)
+				if task_id && track_id
+					task = get_task_by_id(task_id)
+					if task
+						return task.find_track_by_id(track_id)
+					end
+				end
+				
+				nil
 			end
 			
-			def task_apply_push(task, parent_track = nil)
-				task_apply(task, parent_track, true)
+			# Get all [Tasks](rdoc-ref:TheFox::Timr::Model::Task).
+			def tasks
+				load_all_tracks
+				
+				@tasks
 			end
 			
-			def task_apply_pop
-				if @stack.pop
-					update_content_length
-					ui_refresh_simple
+			# Get all [Tracks](rdoc-ref:TheFox::Timr::Model::Track).
+			# 
+			# Options:
+			# 
+			# - `:sort` (Boolean)
+			def tracks(options = Hash.new)
+				sort_opt = options.fetch(:sort, true)
+				
+				load_all_tracks
+				
+				filtered_tracks = Hash.new
+				@tasks.each do |task_id, task|
+					tracks = task.tracks(options)
+					filtered_tracks.merge!(tracks)
+				end
+				
+				if sort_opt
+					# Sort ASC by Begin DateTime, End DateTime.
+					filtered_tracks.sort{ |t1, t2|
+						t1 = t1.last
+						t2 = t2.last
+						
+						cmp1 = t1.begin_datetime <=> t2.begin_datetime
+						
+						if cmp1 == 0
+							t1.end_datetime <=> t2.end_datetime
+						else
+							cmp1
+						end
+					}.to_h
+				else
+					filtered_tracks
 				end
 			end
 			
-			# Update only Windows which shows the data. For example,
-			# if a task is created all Windows needs to know this,
-			# and only Windows which are using the tasks.
-			# Not only the length of the rows can change, but also
-			# the actual an change.
-			def window_content_changed
-				@window_tasks.content_changed
-				@window_timeline.content_changed
-			end
+			# Alias for `ForeignIdDb#match_task_with_foreign_id`.
+			# def match_task_with_foreign_id(task, foreign_id)
+			# end
 			
-			def window_page_object
-				object = @window.page_object if !@window.nil?
-				
-				task = nil
-				track = nil
-				if object.is_a?(Task)
-					task = object
-				elsif object.is_a?(Track)
-					task = object.task
-					track = object
-				end
+			# Save [Stack](rdoc-ref:TheFox::Timr::Model::Stack) and [Config](rdoc-ref:TheFox::Timr::Model::Config).
+			def shutdown
+				# Save Stack
+				@stack.save_to_file
+				
+				# Save config
+				@config.save_to_file
 				
-				[task, track]
+				# Save Foreign ID DB
+				@foreign_id_db.save_to_file
 			end
 			
-			def write_all_data
-				if @last_write.nil?
-					@last_write = Time.now
-				else
-					if Time.now - @last_write >= 300
-						tasks_save(true)
+			# Load all [Tracks](rdoc-ref:TheFox::Timr::Model::Track) using `get_task_by_id`.
+			def load_all_tracks
+				# Iterate all files.
+				@tasks_path.find.each do |file|
+					# Filter all directories.
+					unless file.file?
+						next
 					end
-				end
-			end
-			
-			def run
-				ui_init_curses
-				update_content_length
-				ui_title_line
-				ui_status_line(true)
-				ui_window_show(@window_timeline)
-				
-				loop do
-					key_pressed = Curses.getch
 					
-					case key_pressed
-					when Curses::Key::NPAGE
-						@window.next_page if !@window.nil?
-						
-						# if $DEBUG
-						# 	ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes])
-						# end
-						
-						ui_window_refresh_all
-					when Curses::Key::PPAGE
-						@window.previous_page if !@window.nil?
-						
-						# if $DEBUG
-						# 	ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes])
-						# end
-						
-						ui_window_refresh_all
-					when Curses::Key::DOWN
-						if !@window.nil? && @window.has_cursor?
-							simple_refresh_b = @window.cursor_on_inner_range?
-							
-							@window.cursor_next_line
-							
-							simple_refresh_a = @window.cursor_on_inner_range?
-							
-							# if $DEBUG
-							# 	ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d %02d %02d %s %s' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes, @window.cursor_border_top, @window.cursor_border_bottom, simple_refresh_b ? 'SIMPLE' : 'FULL', simple_refresh_a ? 'SIMPLE' : 'FULL'])
-							#end
-							
-							ui_window_refresh_all
-						end
-					when Curses::Key::UP
-						if !@window.nil? && @window.has_cursor?
-							simple_refresh_b = @window.cursor_on_inner_range?
-							
-							@window.cursor_previous_line
-							
-							simple_refresh_a = @window.cursor_on_inner_range?
-							
-							# if $DEBUG
-							# 	ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d %02d %02d %s %s' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes, @window.cursor_border_top, @window.cursor_border_bottom, simple_refresh_b ? 'SIMPLE' : 'FULL', simple_refresh_a ? 'SIMPLE' : 'FULL'])
-							# end
-							
-							ui_window_refresh_all
-						end
-					when Curses::Key::HOME
-						@window.first_page if !@window.nil?
-						
-						if $DEBUG
-							ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes])
-						end
-						
-						ui_window_refresh_all
-					when Curses::Key::END
-						@window.last_page if !@window.nil?
-						
-						# if $DEBUG
-						# 	ui_status_text('DEBUG: %03d C=%03d L=%03d pr=%03d cr=%03d' % [@window.cursor, ui_content_length, @window.current_line, @window.page_refreshes, @window.content_refreshes])
-						# end
-						
-						ui_window_refresh_all
-					when Curses::Key::DC
-						task, track = window_page_object
-						
-						if track.nil?
-							# Remove Task
-						else
-							# Remove Track
-						end
-						task.remove_track(track)
-						
-						ui_status_text("Del '#{task.class}' '#{track.class}'")
-					when Curses::Key::RESIZE
-						update_content_length
-						ui_status_text("Window size: #{Curses.cols}x#{Curses.lines}")
-						
-						# Refreshing the complete screen while resizing
-						# can make everything slower. So for fast resizing
-						# comment this line.
-						ui_refresh_all
-					when 10
-						task, track = window_page_object
-						
-						# if track.nil?
-						# 	track = Track.new
-						# 	track.task = task
-						# end
-						
-						task_apply_replace_stack(task, track)
-					when '#'
-						task, * = window_page_object
-						
-						track_description = ui_status_input('Track Description: ')
-						
-						track = Track.new
-						track.task = task
-						track.description = track_description
-						
-						task_apply_replace_stack(task, track)
-						ui_status_text('OK')
-					when 'b', 'p'
-						task, track = window_page_object
-						
-						if task.nil?
-							ui_status_text("Unrecognized object: #{object.class}")
-						else
-							task_apply_push(task, track)
-						end
-					when 'r'
-						ui_refresh_all
-						ui_status_text
-					when 'n'
-						task_name = ui_status_input('New task: ')
-						if task_name.nil?
-							ui_status_text('Aborted.')
-						else
-							task = Task.new
-							task.name = task_name
-							task.save_to_file(@data_dir_path)
-							
-							task_apply_replace_stack(task)
-							
-							ui_status_text("Task '#{task_name}' created.")
-						end
-					when 't'
-						task_name = ui_status_input('New task: ')
-						if task_name.nil?
-							ui_status_text('Aborted.')
-						else
-							task = Task.new
-							task.name = task_name
-							task.save_to_file(@data_dir_path)
-							
-							@tasks[task.id] = task
-							
-							update_content_length
-							window_content_changed
-							ui_stack_lines_refresh
-							ui_window_refresh_all
-							
-							ui_status_text("Task '#{task_name}' created.")
-						end
-					when 'x'
-						@stack.task.pause if @stack.has_task?
-						window_content_changed
-						ui_refresh_simple
-					when 'c'
-						@stack.task.toggle if @stack.has_task?
-						window_content_changed
-						ui_refresh_simple
-					when 'v'
-						task_apply_pop
-					when 'f'
-						task_apply_stack_pop_all
-					when 'h', '?'
-						ui_window_show(@window_help)
-					when '1'
-						ui_window_show(@window_timeline)
-					when '2'
-						ui_window_show(@window_tasks)
-					when 'z' # Test Windows
-						ui_window_show(@window_test)
-					when 'w'
-						tasks_save(true)
-					when 'q'
-						break
-					when nil
-						# Do some work.
-						ui_status_line
-						write_all_data
-					else
-						ui_status_text_error("Invalid key '#{key_pressed}' (#{Curses.keyname(key_pressed)})")
+					# Filter all non-yaml files.
+					unless file.basename.fnmatch('*.yml')
+						next
 					end
+					
+					track_id = BasicModel.get_id_from_path(@tasks_path, file)
+					
+					# Loads the Task from file into @tasks.
+					get_task_by_id(track_id)
 				end
 			end
 			
-			def close
-				Curses.stdscr.clear
-				Curses.stdscr.refresh
-				Curses.stdscr.close
-				
-				Curses.close_screen
-				
-				tasks_stop
-				tasks_save
+			def to_s
+				'Timr'
 			end
 			
-		end
-		
-	end
-end
+		end # class Timr
+	
+	end # module Timr
+end # module TheFox