Initial planning for usage

My intention is that this program will be something you can call up when
beginning a task, and just say "I'm starting this task" and then forget
about it for a while. No running processes taking up CPU or problematic
buttons clicking and unclicking when you don't want them too.

When you've worked on a project for a while and want to make sure you
remember what you've done, you'll want to add information to your task.
Such as saying "fixed the problem with the null pointer" "fixed memory
leak from not using an indirection pointer with free" and those types of
things. It should be EASY to do this and not take more than a few simple
commands and the information you want to type in.

Once you're done with a task you should be able to say that it's done
and finish with another simple command. And so you don't forget what
you've done 3 months down the road, it's important to write a small
summary message with the finished task.

Eventually, It would be nice to view the current task going on and see
the relevant information being displayed nicely. Including how long
you've worked on the task.
Inital init function created.

The init function is what's going to kick off every function of tcatch,
this is because we need to create the .tc directory to do anything and
have access to it. Once the init function runs we know for a fact that
we have the proper directory structure to deal with.

A refactor will have to occur to abstract getting the .tc directory
location and making the task directory for the current date. Since we'll
be using the directory each time we create or modify a task.

Also added the valgrind command to check for memory leaks to the readme
file and started a How it works section of the readme. This is not only
for the people who are curious how this program works, but also my
planning area and thinking section.
Abstracted Directory functions

Moved directory handling functions to a tc-directory file and modified
the MakeFile to handle it. tc-init is still the primary file to use as
the main function, but this will probably change once work begins on the
functionality.

Added ignore file to ignore .o files and .out files. I should refactor
the directory structure into a standard library one.
Refactored Directory Structure

Moved headers into header folder, source code files into src and removed
the binary being generated from the repository. Also updated MakeFile to
include the headers path so we're able to build still.
Added basic command parsing

Began adding usage information for each command. General usage created
and displayed when given a command that's not recognized or when no
command is given at all.
Added usage for View command.

Added view usage and parsing for view command to tc-init's main
function. It seems like this should probably be factored out into its
own file later on because it's going to end up making this is a very
long main function otherwise.
Adde usage for start command. Refactored some code

Added usage string for informating the user how to use the software for
the start command call. Still no functionality, just stubbing out where
things are.
Finished Usage for help dialog. Structured flow.

Finished writing the usage for the current commands. While doing so, had
the idea that perhaps I should have a switch task command to let you
switch between tasks. That would be a good idea. Either that or maybe
the start task command could double as that. I'll probably need a remove
task function as well, but for now I'll focus on getting the basics
working.

Added program flow to the main function that describes (at a very high
level) what each command is going to do. No mention of the current task
record file (I haven't decided what to name it yet). A refactor is
neccesary before continued work. The usage should be pushed off into
it's own files. Also. Wondering if I shouldn't check for the -h flag the
way I'm doing it now.

Currently, all the passed in arguments from the command line are looped
through and checked for - and then for --help or -h (all in O(N) time of
course), but should I only except --help/-h as the first arguments to a
command? Or should -h anywhere in the arguments to the program trigger
the help task? Something to consider.
Merge branch 'feature/usage' into develop
Refactored Flag checking

Refactored the flag checking into a simple function that can check for a
long or short version in all arguments passed in.

Updated readme with plans for how I'll keep track of the current task.
Intentions are to have a current file pointing at the sha1 of the
current task and its location directory for the start task, then
pointers to any of the intermediate "pause" files at all. And of course
the location of a finished task file or not.

Added TRUE and FALSE defines into tc-init. I think a refactor for
tc-init into its own c and header file and the main program being placed
into its own file is due.
Updated MakeFile. Refactored init coder to headers

Created the tc-init header file and moved the main file into a tcatch.c
file that will function as the primary flow control area for the
program.

Updated makefile to use the new header and target the tcatch.c file.
Format defined and task name hashing

Create task structure to store information about an individual task.
Defined new scheme for directory structure for the tc system. Within the
.tc directory there is an indexes folder that contains where the
timeline of all tasks will be. This is your history essentially and will
contain a sequence of all tasks worked on.

Each task file is stored in two files. A .seq file and a .info file. The
sequence file (.seq) is used to stored start,pauses,resumes and finishes
of a task as well as the epoch times neccesary to calculate information
about a task. The information file (.info) is just a simple file that
stores the name of the task (in human readable form) and any
information added by the add-info command/

Began work on the task write function that will do the job of creating a
tasks .seq and .info file and updating the master index files.
Updated readme with file changes

Updated readme with information about the uses for the .seq and .info
files. It's not a detail on the format, if thats what you want to see
checkout the tc-catch.c files write function.
Fixed segmentation fault from sprintf

The filehash string wasn't being created properly. Not being initialized
and a host of other issues that resulted in a segment fault. This has
been fixed, although now we have to make sure to free the fileHashName
pointer.
Finish task write function

Added file manipulation to create the index file and the
seqeuence/information files. The sequence and information files have
information appended into them. They do rely on the calling function to
instantiate the struct, but that's to be expected. It's not the write
jobs job to populate the task struct, only to write it out.

Added initial default values for a struct into the calling tcatch file
and defined some more constants.
Merge branch 'feature/task-write' into develop
Functionality for finding current task

Functionality for finding the current task and additions to make the
write task functions work properly. (Not over-writing the current task
and such).

Stubbed out some high level pieces of the read task function. The read
function will probably be a trickier one because it has to calculate the
start time, end time and any pause time. Pseudo code wise this is
something like:

Start time is the base. Store it.
Look for the next sequence, if its pause then keep track of that until
finding the next start. When that's found, take the difference and store
it as the pause time.
Keep doing that until a finished time is hit, then Take the end time -
start time - pause time to determine the total time spent on the task.

Of course history like functionality would take into account all the
inbetween pauses and such.
Added read functionality and state -> string func.

Added state to string function to transform the defined constants to a
human readable format. This, along with the read function working
correctly (75% -- no info yet) allows the regular tcatch view command to
work correctly.

Now I just need to have it read information in and allow for the view
command to take a --verbose argument to render the entire informational
tidbits about the task.

A refactor may be in order soon. The tcatch file is getting a bit wordy.
Refactored view code to file

Moved code for showing the 'short' version or long version (depending on
the value of the verbose Flag passed in) to its own file -- that way the
other viewing functions can be placed in there as well (such as doing a
more comprehensive bit of viewing.

Malloc-ing taskInfo's pointer now within the working struct, this means
that that pointer must be freed by calling functions, or calling
functions should not exit willy nilly.

Came up with a scheme for rendering the info file. This is detailed in
two long (but identical) comments within the source code (specifically
super man). Essentially, the info file is never read into a variable to
be manipulated, it is piped from the file out onto the stdio stream. Or
at least, that's the plan.
Fixed read to load any named task.

The read function was only reading the current task before, for view
purposes we need to be able to any task at all. So the code that was
written when I was tired and not thinking has been removed.