From c3caecaeb75434e8383bc52d45a17e802d277c2f Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Mon, 29 Aug 2016 08:58:00 +0200
Subject: [PATCH 01/18] Structure refactoring, splitting to smaller logical
 files

---
 setup.py            |   7 +-
 ti/__init__.py      | 423 +-------------------------------------------
 ti/actions.py       | 218 +++++++++++++++++++++++
 ti/colors.py        |  30 ++++
 ti/time_tracking.py | 123 +++++++++++++
 ti/utils.py         |  69 ++++++++
 6 files changed, 449 insertions(+), 421 deletions(-)
 create mode 100644 ti/actions.py
 create mode 100644 ti/colors.py
 create mode 100644 ti/time_tracking.py
 create mode 100644 ti/utils.py

diff --git a/setup.py b/setup.py
index 013e357..66fa6d1 100755
--- a/setup.py
+++ b/setup.py
@@ -29,10 +29,13 @@ def read(*filenames, **kwargs):
     long_description=read('README.rst', 'CHANGES.rst'),
     entry_points={
         'console_scripts': [
-            'ti = ti:main',
+            'ti = ti.time_tracking:main',
         ]
     },
-    install_requires=["colorama", "pyyaml"],
+    install_requires=[
+        "colorama",
+        "PyYAML",
+    ],
     setup_requires=["pytest-runner"] if testing else [],
     tests_require=["pytest", "cram", "pytest-cram"],
     extras_require={
diff --git a/ti/__init__.py b/ti/__init__.py
index 483736f..8c354f8 100755
--- a/ti/__init__.py
+++ b/ti/__init__.py
@@ -1,46 +1,8 @@
 # coding: utf-8
-
-"""
-ti is a simple and extensible time tracker for the command line. Visit the
-project page (http://ti.sharats.me) for more details.
-
-Usage:
-  ti (o|on) <name> [<time>...]
-  ti (f|fin) [<time>...]
-  ti (s|status)
-  ti (t|tag) <tag>...
-  ti (n|note) <note-text>...
-  ti (l|log) [today]
-  ti (e|edit)
-  ti (i|interrupt)
-  ti --no-color
-  ti -h | --help
-
-Options:
-  -h --help         Show this help.
-  <start-time>...   A time specification (goto http://ti.sharats.me for more on
-                    this).
-  <tag>...          Tags can be made of any characters, but its probably a good
-                    idea to avoid whitespace.
-  <note-text>...    Some arbitrary text to be added as `notes` to the currently
-                    working project.
-"""
-
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import json
 import os
-import re
-import subprocess
-import sys
-import tempfile
-from datetime import datetime, timedelta
-from collections import defaultdict
-from os import path
+import json
 
-import yaml
-from colorama import Fore
+__version__ = '0.1.1.dev1'
 
 
 class JsonStore(object):
@@ -50,7 +12,7 @@ def __init__(self, filename):
 
     def load(self):
 
-        if path.exists(self.filename):
+        if os.path.exists(self.filename):
             with open(self.filename) as f:
                 data = json.load(f)
 
@@ -64,381 +26,4 @@ def dump(self, data):
             json.dump(data, f, separators=(',', ': '), indent=2)
 
 
-def red(str):
-    if use_color:
-        return Fore.RED + str + Fore.RESET
-    else:
-        return str
-
-
-def green(str):
-    if use_color:
-        return Fore.GREEN + str + Fore.RESET
-    else:
-        return str
-
-
-def yellow(str):
-    if use_color:
-        return Fore.YELLOW + str + Fore.RESET
-    else:
-        return str
-
-
-def blue(str):
-    if use_color:
-        return Fore.BLUE + str + Fore.RESET
-    else:
-        return str
-
-
-def action_on(name, time):
-    data = store.load()
-    work = data['work']
-
-    if work and 'end' not in work[-1]:
-        print('You are already working on ' + yellow(work[-1]['name']) +
-              '. Stop it or use a different sheet.', file=sys.stderr)
-        raise SystemExit(1)
-
-    entry = {
-        'name': name,
-        'start': time,
-    }
-
-    work.append(entry)
-    store.dump(data)
-
-    print('Start working on ' + green(name) + '.')
-
-
-def action_fin(time, back_from_interrupt=True):
-    ensure_working()
-
-    data = store.load()
-
-    current = data['work'][-1]
-    current['end'] = time
-    store.dump(data)
-    print('So you stopped working on ' + red(current['name']) + '.')
-
-    if back_from_interrupt and len(data['interrupt_stack']) > 0:
-        name = data['interrupt_stack'].pop()['name']
-        store.dump(data)
-        action_on(name, time)
-        if len(data['interrupt_stack']) > 0:
-            print('You are now %d deep in interrupts.'
-                  % len(data['interrupt_stack']))
-        else:
-            print('Congrats, you\'re out of interrupts!')
-
-
-def action_interrupt(name, time):
-    ensure_working()
-
-    action_fin(time, back_from_interrupt=False)
-
-    data = store.load()
-    if 'interrupt_stack' not in data:
-        data['interrupt_stack'] = []
-    interrupt_stack = data['interrupt_stack']
-
-    interrupted = data['work'][-1]
-    interrupt_stack.append(interrupted)
-    store.dump(data)
-
-    action_on('interrupt: ' + green(name), time)
-    print('You are now %d deep in interrupts.' % len(interrupt_stack))
-
-
-def action_note(content):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    if 'notes' not in current:
-        current['notes'] = [content]
-    else:
-        current['notes'].append(content)
-
-    store.dump(data)
-
-    print('Yep, noted to ' + yellow(current['name']) + '.')
-
-
-def action_tag(tags):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    current['tags'] = set(current.get('tags') or [])
-    current['tags'].update(tags)
-    current['tags'] = list(current['tags'])
-
-    store.dump(data)
-
-    tag_count = str(len(tags))
-    print('Okay, tagged current work with ' + tag_count + ' tag' +
-          ('s' if tag_count > 1 else '') + '.')
-
-
-def action_status():
-    try:
-        ensure_working()
-    except SystemExit(1):
-        return
-
-    data = store.load()
-    current = data['work'][-1]
-
-    start_time = parse_isotime(current['start'])
-    diff = timegap(start_time, datetime.utcnow())
-
-    print('You have been working on {0} for {1}.'.format(
-        green(current['name']), diff))
-
-
-def action_log(period):
-    data = store.load()
-    work = data['work'] + data['interrupt_stack']
-    log = defaultdict(lambda: {'delta': timedelta()})
-    current = None
-
-    for item in work:
-        start_time = parse_isotime(item['start'])
-        if 'end' in item:
-            log[item['name']]['delta'] += (
-                parse_isotime(item['end']) - start_time)
-        else:
-            log[item['name']]['delta'] += datetime.utcnow() - start_time
-            current = item['name']
-
-    name_col_len = 0
-
-    for name, item in log.items():
-        name_col_len = max(name_col_len, len(name))
-
-        secs = item['delta'].seconds
-        tmsg = []
-
-        if secs > 3600:
-            hours = int(secs / 3600)
-            secs -= hours * 3600
-            tmsg.append(str(hours) + ' hour' + ('s' if hours > 1 else ''))
-
-        if secs > 60:
-            mins = int(secs / 60)
-            secs -= mins * 60
-            tmsg.append(str(mins) + ' minute' + ('s' if mins > 1 else ''))
-
-        if secs:
-            tmsg.append(str(secs) + ' second' + ('s' if secs > 1 else ''))
-
-        log[name]['tmsg'] = ', '.join(tmsg)[::-1].replace(',', '& ', 1)[::-1]
-
-    for name, item in sorted(log.items(), key=(lambda x: x[1]), reverse=True):
-        print(name.ljust(name_col_len), ' ∙∙ ', item['tmsg'],
-              end=' ← working\n' if current == name else '\n')
-
-
-def action_edit():
-    if 'EDITOR' not in os.environ:
-        print("Please set the 'EDITOR' environment variable", file=sys.stderr)
-        raise SystemExit(1)
-
-    data = store.load()
-    yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
-
-    cmd = os.getenv('EDITOR')
-    fd, temp_path = tempfile.mkstemp(prefix='ti.')
-    with open(temp_path, "r+") as f:
-        f.write(yml.replace('\n- ', '\n\n- '))
-        f.seek(0)
-        subprocess.check_call(cmd + ' ' + temp_path, shell=True)
-        yml = f.read()
-        f.truncate()
-        f.close
-
-    os.close(fd)
-    os.remove(temp_path)
-
-    try:
-        data = yaml.load(yml)
-    except:
-        print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
-        raise SystemExit(1)
-
-    store.dump(data)
-
-
-def is_working():
-    data = store.load()
-    return data.get('work') and 'end' not in data['work'][-1]
-
-
-def ensure_working():
-    if is_working():
-        return
-
-    print("For all I know, you aren't working on anything. "
-          "I don't know what to do.", file=sys.stderr)
-    print('See `ti -h` to know how to start working.', file=sys.stderr)
-    raise SystemExit(1)
-
-
-def to_datetime(timestr):
-    return parse_engtime(timestr).isoformat() + 'Z'
-
-
-def parse_engtime(timestr):
-
-    now = datetime.utcnow()
-    if not timestr or timestr.strip() == 'now':
-        return now
-
-    match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
-                     timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        seconds = 1 if n == 'a' else int(n)
-        return now - timedelta(seconds=seconds)
-
-    match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        minutes = 1 if n == 'a' else int(n)
-        return now - timedelta(minutes=minutes)
-
-    match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        hours = 1 if n in ['a', 'an'] else int(n)
-        return now - timedelta(hours=hours)
-
-    raise ValueError("Don't understand the time '" + timestr + "'")
-
-
-def parse_isotime(isotime):
-    return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
-
-
-def timegap(start_time, end_time):
-    diff = end_time - start_time
-
-    mins = diff.seconds / 60
-
-    if mins == 0:
-        return 'less than a minute'
-    elif mins == 1:
-        return 'a minute'
-    elif mins < 44:
-        return '{} minutes'.format(mins)
-    elif mins < 89:
-        return 'about an hour'
-    elif mins < 1439:
-        return 'about {} hours'.format(mins / 60)
-    elif mins < 2519:
-        return 'about a day'
-    elif mins < 43199:
-        return 'about {} days'.format(mins / 1440)
-    elif mins < 86399:
-        return 'about a month'
-    elif mins < 525599:
-        return 'about {} months'.format(mins / 43200)
-    else:
-        return 'more than a year'
-
-
-def helpful_exit(msg=__doc__):
-    print(msg, file=sys.stderr)
-    raise SystemExit
-
-
-def parse_args(argv=sys.argv):
-    global use_color
-
-    argv = [arg.decode('utf-8') for arg in argv]
-
-    if '--no-color' in argv:
-        use_color = False
-        argv.remove('--no-color')
-
-    # prog = argv[0]
-    if len(argv) == 1:
-        helpful_exit('You must specify a command.')
-
-    head = argv[1]
-    tail = argv[2:]
-
-    if head in ['-h', '--help', 'h', 'help']:
-        helpful_exit()
-
-    elif head in ['e', 'edit']:
-        fn = action_edit
-        args = {}
-
-    elif head in ['o', 'on']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_on
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    elif head in ['f', 'fin']:
-        fn = action_fin
-        args = {'time': to_datetime(' '.join(tail))}
-
-    elif head in ['s', 'status']:
-        fn = action_status
-        args = {}
-
-    elif head in ['l', 'log']:
-        fn = action_log
-        args = {'period': tail[0] if tail else None}
-
-    elif head in ['t', 'tag']:
-        if not tail:
-            helpful_exit('Please provide at least one tag to add.')
-
-        fn = action_tag
-        args = {'tags': tail}
-
-    elif head in ['n', 'note']:
-        if not tail:
-            helpful_exit('Please provide some text to be noted.')
-
-        fn = action_note
-        args = {'content': ' '.join(tail)}
-
-    elif head in ['i', 'interrupt']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_interrupt
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    else:
-        helpful_exit("I don't understand '" + head + "'")
-
-    return fn, args
-
-
-def main():
-    fn, args = parse_args()
-    fn(**args)
-
-
-store = JsonStore(os.getenv('SHEET_FILE', None) or
-                  os.path.expanduser('~/.ti-sheet'))
-use_color = True
-
-if __name__ == '__main__':
-    main()
+store = JsonStore(os.getenv('SHEET_FILE', None) or os.path.expanduser('~/.ti-sheet'))
diff --git a/ti/actions.py b/ti/actions.py
new file mode 100644
index 0000000..7bb2e17
--- /dev/null
+++ b/ti/actions.py
@@ -0,0 +1,218 @@
+# coding: utf-8
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import yaml
+import os
+import subprocess
+import sys
+import tempfile
+from datetime import timedelta
+from collections import defaultdict
+from ti.colors import red, yellow, green
+from ti.utils import datetime, parse_isotime, timegap
+from ti import store
+
+
+def action_on(name, time):
+    data = store.load()
+    work = data['work']
+
+    if work and 'end' not in work[-1]:
+        print('You are already working on ' + yellow(work[-1]['name']) +
+              '. Stop it or use a different sheet.', file=sys.stderr)
+        raise SystemExit(1)
+
+    entry = {
+        'name': name,
+        'start': time,
+    }
+
+    work.append(entry)
+    store.dump(data)
+
+    print('Start working on ' + green(name) + '.')
+
+
+def action_fin(time, back_from_interrupt=True):
+    ensure_working()
+
+    data = store.load()
+
+    current = data['work'][-1]
+    current['end'] = time
+    store.dump(data)
+    print('So you stopped working on ' + red(current['name']) + '.')
+
+    if back_from_interrupt and len(data['interrupt_stack']) > 0:
+        name = data['interrupt_stack'].pop()['name']
+        store.dump(data)
+        action_on(name, time)
+        if len(data['interrupt_stack']) > 0:
+            print('You are now %d deep in interrupts.'
+                  % len(data['interrupt_stack']))
+        else:
+            print('Congrats, you\'re out of interrupts!')
+
+
+def action_interrupt(name, time):
+    ensure_working()
+
+    action_fin(time, back_from_interrupt=False)
+
+    data = store.load()
+    if 'interrupt_stack' not in data:
+        data['interrupt_stack'] = []
+    interrupt_stack = data['interrupt_stack']
+
+    interrupted = data['work'][-1]
+    interrupt_stack.append(interrupted)
+    store.dump(data)
+
+    action_on('interrupt: ' + green(name), time)
+    print('You are now %d deep in interrupts.' % len(interrupt_stack))
+
+
+def action_note(content):
+    ensure_working()
+
+    data = store.load()
+    current = data['work'][-1]
+
+    if 'notes' not in current:
+        current['notes'] = [content]
+    else:
+        current['notes'].append(content)
+
+    store.dump(data)
+
+    print('Yep, noted to ' + yellow(current['name']) + '.')
+
+
+def action_tag(tags):
+    ensure_working()
+
+    data = store.load()
+    current = data['work'][-1]
+
+    current['tags'] = set(current.get('tags') or [])
+    current['tags'].update(tags)
+    current['tags'] = list(current['tags'])
+
+    store.dump(data)
+
+    tag_count = str(len(tags))
+    print('Okay, tagged current work with ' + tag_count + ' tag' +
+          ('s' if tag_count > 1 else '') + '.')
+
+
+def action_status():
+    try:
+        ensure_working()
+    except SystemExit(1):
+        return
+
+    data = store.load()
+    current = data['work'][-1]
+
+    start_time = parse_isotime(current['start'])
+    diff = timegap(start_time, datetime.utcnow())
+
+    print('You have been working on {0} for {1}.'.format(
+        green(current['name']), diff))
+
+
+def action_log(period):
+    data = store.load()
+    work = data['work'] + data['interrupt_stack']
+    log = defaultdict(lambda: {'delta': timedelta()})
+    current = None
+    name_col_len = 0
+
+    for item in work:
+        start_time = parse_isotime(item['start'])
+        if 'end' in item:
+            log[item['name']]['delta'] += (
+                parse_isotime(item['end']) - start_time)
+        else:
+            log[item['name']]['delta'] += datetime.utcnow() - start_time
+            current = item['name']
+
+    for name, item in log.items():
+        name_col_len = max(name_col_len, len(name))
+
+        secs = item['delta'].seconds
+        tmsg = []
+
+        if secs > 3600:
+            hours = int(secs / 3600)
+            secs -= hours * 3600
+            tmsg.append(str(hours) + ' hour' + ('s' if hours > 1 else ''))
+
+        if secs > 60:
+            mins = int(secs / 60)
+            secs -= mins * 60
+            tmsg.append(str(mins) + ' minute' + ('s' if mins > 1 else ''))
+
+        if secs:
+            tmsg.append(str(secs) + ' second' + ('s' if secs > 1 else ''))
+
+        log[name]['tmsg'] = ', '.join(tmsg)[::-1].replace(',', '& ', 1)[::-1]
+
+    log_list = []
+    for name, item in log.items():
+        log_list.append(
+            (
+                name,
+                item['delta'],
+                item['tmsg']
+            )
+        )
+    for name, delta, tmsg in sorted(log_list, key=lambda x: x[0], reverse=True):
+        print(name.ljust(name_col_len), ' ∙∙ ', tmsg,
+              end=' ← working\n' if current == name else '\n')
+
+
+def action_edit():
+    if 'EDITOR' not in os.environ:
+        print("Please set the 'EDITOR' environment variable", file=sys.stderr)
+        raise SystemExit(1)
+
+    data = store.load()
+    yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
+
+    cmd = os.getenv('EDITOR')
+    fd, temp_path = tempfile.mkstemp(prefix='ti.')
+    with open(temp_path, "r+") as f:
+        f.write(yml.replace('\n- ', '\n\n- '))
+        f.seek(0)
+        subprocess.check_call(cmd + ' ' + temp_path, shell=True)
+        yml = f.read()
+        f.truncate()
+        f.close()
+
+    os.close(fd)
+    os.remove(temp_path)
+
+    try:
+        data = yaml.load(yml)
+    except:
+        print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
+        raise SystemExit(1)
+
+    store.dump(data)
+
+
+def is_working():
+    data = store.load()
+    return data.get('work') and 'end' not in data['work'][-1]
+
+
+def ensure_working():
+    if is_working():
+        return
+
+    print("For all I know, you aren't working on anything. "
+          "I don't know what to do.", file=sys.stderr)
+    print('See `ti -h` to know how to start working.', file=sys.stderr)
+    raise SystemExit(1)
diff --git a/ti/colors.py b/ti/colors.py
new file mode 100644
index 0000000..213e2c7
--- /dev/null
+++ b/ti/colors.py
@@ -0,0 +1,30 @@
+# coding: utf-8
+from colorama import Fore
+
+
+def red(_str, use_color=False):
+    if use_color:
+        return Fore.RED + _str + Fore.RESET
+    else:
+        return _str
+
+
+def green(_str, use_color=False):
+    if use_color:
+        return Fore.GREEN + _str + Fore.RESET
+    else:
+        return _str
+
+
+def yellow(_str, use_color=False):
+    if use_color:
+        return Fore.YELLOW + _str + Fore.RESET
+    else:
+        return _str
+
+
+def blue(_str, use_color=False):
+    if use_color:
+        return Fore.BLUE + _str + Fore.RESET
+    else:
+        return _str
diff --git a/ti/time_tracking.py b/ti/time_tracking.py
new file mode 100644
index 0000000..52ccccb
--- /dev/null
+++ b/ti/time_tracking.py
@@ -0,0 +1,123 @@
+# coding: utf-8
+"""
+ti is a simple and extensible time tracker for the command line. Visit the
+project page (http://ti.sharats.me) for more details.
+
+Usage:
+  ti (o|on) <name> [<time>...]
+  ti (f|fin) [<time>...]
+  ti (s|status)
+  ti (t|tag) <tag>...
+  ti (n|note) <note-text>...
+  ti (l|log) [today]
+  ti (e|edit)
+  ti (i|interrupt)
+  ti --no-color
+  ti -h | --help
+
+Options:
+  -h --help         Show this help.
+  <start-time>...   A time specification (goto http://ti.sharats.me for more on
+                    this).
+  <tag>...          Tags can be made of any characters, but its probably a good
+                    idea to avoid whitespace.
+  <note-text>...    Some arbitrary text to be added as `notes` to the currently
+                    working project.
+"""
+
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import sys
+from .actions import action_edit, action_fin, action_interrupt, action_log, action_note, action_on, \
+    action_status, action_tag
+from .utils import to_datetime
+
+
+def helpful_exit(msg=__doc__):
+    print(msg, file=sys.stderr)
+    raise SystemExit
+
+
+def parse_args(argv=sys.argv):
+    use_color = False
+
+    argv = [arg for arg in argv]
+
+    if '--no-color' in argv:
+        use_color = False
+        argv.remove('--no-color')
+
+    # prog = argv[0]
+    if len(argv) == 1:
+        helpful_exit('You must specify a command.')
+
+    head = argv[1]
+    tail = argv[2:]
+
+    if head in ['-h', '--help', 'h', 'help']:
+        helpful_exit()
+
+    elif head in ['e', 'edit']:
+        fn = action_edit
+        args = {}
+
+    elif head in ['o', 'on']:
+        if not tail:
+            helpful_exit('Need the name of whatever you are working on.')
+
+        fn = action_on
+        args = {
+            'name': tail[0],
+            'time': to_datetime(' '.join(tail[1:])),
+        }
+
+    elif head in ['f', 'fin']:
+        fn = action_fin
+        args = {'time': to_datetime(' '.join(tail))}
+
+    elif head in ['s', 'status']:
+        fn = action_status
+        args = {}
+
+    elif head in ['l', 'log']:
+        fn = action_log
+        args = {'period': tail[0] if tail else None}
+
+    elif head in ['t', 'tag']:
+        if not tail:
+            helpful_exit('Please provide at least one tag to add.')
+
+        fn = action_tag
+        args = {'tags': tail}
+
+    elif head in ['n', 'note']:
+        if not tail:
+            helpful_exit('Please provide some text to be noted.')
+
+        fn = action_note
+        args = {'content': ' '.join(tail)}
+
+    elif head in ['i', 'interrupt']:
+        if not tail:
+            helpful_exit('Need the name of whatever you are working on.')
+
+        fn = action_interrupt
+        args = {
+            'name': tail[0],
+            'time': to_datetime(' '.join(tail[1:])),
+        }
+
+    else:
+        helpful_exit("I don't understand '" + head + "'")
+
+    return fn, args
+
+
+def main():
+    fn, args = parse_args()
+    fn(**args)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/ti/utils.py b/ti/utils.py
new file mode 100644
index 0000000..74a68d1
--- /dev/null
+++ b/ti/utils.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import re
+from datetime import datetime, timedelta
+
+
+def to_datetime(timestr):
+    return parse_engtime(timestr).isoformat() + 'Z'
+
+
+def parse_engtime(timestr):
+
+    now = datetime.utcnow()
+    if not timestr or timestr.strip() == 'now':
+        return now
+
+    match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
+                     timestr, re.X)
+    if match is not None:
+        n = match.group(1)
+        seconds = 1 if n == 'a' else int(n)
+        return now - timedelta(seconds=seconds)
+
+    match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
+    if match is not None:
+        n = match.group(1)
+        minutes = 1 if n == 'a' else int(n)
+        return now - timedelta(minutes=minutes)
+
+    match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
+    if match is not None:
+        n = match.group(1)
+        hours = 1 if n in ['a', 'an'] else int(n)
+        return now - timedelta(hours=hours)
+
+    raise ValueError("Don't understand the time '" + timestr + "'")
+
+
+def parse_isotime(isotime):
+    return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
+
+
+def timegap(start_time, end_time):
+    diff = end_time - start_time
+
+    mins = diff.seconds / 60
+
+    if mins == 0:
+        return 'less than a minute'
+    elif mins == 1:
+        return 'a minute'
+    elif mins < 44:
+        return '{} minutes'.format(mins)
+    elif mins < 89:
+        return 'about an hour'
+    elif mins < 1439:
+        return 'about {} hours'.format(mins / 60)
+    elif mins < 2519:
+        return 'about a day'
+    elif mins < 43199:
+        return 'about {} days'.format(mins / 1440)
+    elif mins < 86399:
+        return 'about a month'
+    elif mins < 525599:
+        return 'about {} months'.format(mins / 43200)
+    else:
+        return 'more than a year'

From e6a579fe8c59c02564c98b87e553963d07de9009 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Mon, 29 Aug 2016 08:58:35 +0200
Subject: [PATCH 02/18] Moved version to __init__

---
 setup.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 66fa6d1..be0f551 100755
--- a/setup.py
+++ b/setup.py
@@ -3,6 +3,7 @@
 import sys
 
 from setuptools import find_packages, setup
+import ti
 
 
 def read(*filenames, **kwargs):
@@ -18,7 +19,7 @@ def read(*filenames, **kwargs):
 
 setup(
     name="ti",
-    version="0.1.1.dev0",
+    version=ti.__version__,
     author="Shrikant Sharat",
     author_email="shrikantsharat.k@gmail.com",
     packages=find_packages(),

From 2d95ffeea901ced130c247fc37c9f31b9f8b6c0b Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Mon, 29 Aug 2016 08:59:39 +0200
Subject: [PATCH 03/18] Added .idea folder to .gitignore

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 89e8265..821089d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,6 +24,9 @@ var/
 .installed.cfg
 *.egg
 
+# IDE's
+/.idea
+
 # Installer logs
 pip-log.txt
 pip-delete-this-directory.txt

From 378c3bce745cb62a44794c9e1eaa543e43b25b9d Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Mon, 29 Aug 2016 09:23:57 +0200
Subject: [PATCH 04/18] Added tabulate to help display log as proper aligned
 table

---
 setup.py      |  1 +
 ti/actions.py | 13 +++++--------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/setup.py b/setup.py
index be0f551..0675a26 100755
--- a/setup.py
+++ b/setup.py
@@ -36,6 +36,7 @@ def read(*filenames, **kwargs):
     install_requires=[
         "colorama",
         "PyYAML",
+        "tabulate"
     ],
     setup_requires=["pytest-runner"] if testing else [],
     tests_require=["pytest", "cram", "pytest-cram"],
diff --git a/ti/actions.py b/ti/actions.py
index 7bb2e17..167de86 100644
--- a/ti/actions.py
+++ b/ti/actions.py
@@ -12,6 +12,7 @@
 from ti.colors import red, yellow, green
 from ti.utils import datetime, parse_isotime, timegap
 from ti import store
+from tabulate import tabulate
 
 
 def action_on(name, time):
@@ -127,7 +128,6 @@ def action_log(period):
     work = data['work'] + data['interrupt_stack']
     log = defaultdict(lambda: {'delta': timedelta()})
     current = None
-    name_col_len = 0
 
     for item in work:
         start_time = parse_isotime(item['start'])
@@ -139,8 +139,6 @@ def action_log(period):
             current = item['name']
 
     for name, item in log.items():
-        name_col_len = max(name_col_len, len(name))
-
         secs = item['delta'].seconds
         tmsg = []
 
@@ -164,13 +162,12 @@ def action_log(period):
         log_list.append(
             (
                 name,
-                item['delta'],
-                item['tmsg']
+                item['tmsg'],
+                ' ← working' if current == name else ''
             )
         )
-    for name, delta, tmsg in sorted(log_list, key=lambda x: x[0], reverse=True):
-        print(name.ljust(name_col_len), ' ∙∙ ', tmsg,
-              end=' ← working\n' if current == name else '\n')
+    data = sorted(log_list, key=lambda x: x[0], reverse=True)
+    print(tabulate(data))
 
 
 def action_edit():

From e743aa8c10db8cb75dc6868215eeeda5e6c73967 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:14:12 +0200
Subject: [PATCH 05/18] Added store for sqlite

---
 ti/store.py | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 ti/store.py

diff --git a/ti/store.py b/ti/store.py
new file mode 100644
index 0000000..b35af9a
--- /dev/null
+++ b/ti/store.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+import sqlite3
+import os
+
+
+class Store(object):
+    store_file = '~/.ti-sheet.sqlite'
+    conn = None
+    fields = [
+        'id', 'start', 'end', 'start_date', 'in_seconds', 'is_current', 'project', 'task']
+
+    def __init__(self):
+        store_path = os.path.expanduser(self.store_file)
+        self.conn = sqlite3.connect(store_path, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
+        self.conn.row_factory = sqlite3.Row
+
+        with self.conn:
+            res = self.conn.execute('PRAGMA TABLE_INFO(tracking)')
+            names = [tup[1] for tup in res.fetchall()]
+            if not all(x in self.fields for x in names):
+                self.create_schema()
+
+    def create_schema(self):
+        c = self.conn.cursor()
+        ddl = """
+            create table tracking (
+              id integer PRIMARY KEY ,
+              start text,
+              end text,
+              start_date text,
+              in_seconds integer,
+              is_current integer,
+              project text,
+              task text
+            );
+        """
+        try:
+            c.execute(ddl)
+        except sqlite3.OperationalError:
+            pass
+
+    def get_current(self):
+        c = self.conn.cursor()
+        c.execute("select * from tracking where is_current = 1 order by start desc;")
+        row = c.fetchone()
+        if row:
+            return row
+        else:
+            return None
+
+    def add_tracking(self, task, project, start):
+        with self.conn:
+            self.conn.execute("insert into tracking (start, start_date, is_current, project, task)"
+                              " values (?, ?, ?, ?, ?)", (str(start), str(start.to_date_string()), True, project, task))
+
+    def finish_tracking(self, current, end):
+        with self.conn:
+            self.conn.execute("update tracking set is_current = ?, end = ?, in_seconds = ? where id = ?",
+                              (False, str(end), (end-current['start']).total_seconds(), current['id']))
+
+    def get_logs(self, gte, lte):
+        with self.conn:
+            c = self.conn.execute("select * from tracking where start_date >= ? and start_date <= ? order by start",
+                                  (str(gte), str(lte)))
+            return c.fetchall()
+
+    def get_aggregated_logs(self, gte, lte):
+        with self.conn:
+            c = self.conn.execute("select project, task, sum(in_seconds) as total_seconds from tracking "
+                                  "where start_date >= ? and start_date <= ? group by project, task",
+                                  (str(gte), str(lte)))
+            return c.fetchall()

From 63ac6d9a7a844aef36bc7b4dbb63c55d042dd983 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:16:31 +0200
Subject: [PATCH 06/18] Refactored argparse for multicommands

---
 setup.py            |   3 +-
 ti/ti.py            | 176 ++++++++++++++++++++++++++++++++++++++++++++
 ti/time_tracking.py | 123 -------------------------------
 3 files changed, 177 insertions(+), 125 deletions(-)
 create mode 100644 ti/ti.py
 delete mode 100644 ti/time_tracking.py

diff --git a/setup.py b/setup.py
index 0675a26..5cf6e07 100755
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 import io
 import sys
-
 from setuptools import find_packages, setup
 import ti
 
@@ -30,7 +29,7 @@ def read(*filenames, **kwargs):
     long_description=read('README.rst', 'CHANGES.rst'),
     entry_points={
         'console_scripts': [
-            'ti = ti.time_tracking:main',
+            'ti = ti.ti:main',
         ]
     },
     install_requires=[
diff --git a/ti/ti.py b/ti/ti.py
new file mode 100644
index 0000000..4dbb66d
--- /dev/null
+++ b/ti/ti.py
@@ -0,0 +1,176 @@
+# coding: utf-8
+"""
+ti is a simple and extensible time tracker for the command line. Visit the
+project page (http://ti.sharats.me) for more details.
+"""
+
+from __future__ import print_function
+from __future__ import unicode_literals
+import argparse
+import sys
+from .actions import Actions
+import sys
+
+
+# def parse_args(argv=sys.argv):
+#     use_color = False
+#
+#     argv = [arg for arg in argv]
+#
+#     if '--no-color' in argv:
+#         use_color = False
+#         argv.remove('--no-color')
+#
+#     # prog = argv[0]
+#     if len(argv) == 1:
+#         helpful_exit('You must specify a command.')
+#
+#     head = argv[1]
+#     tail = argv[2:]
+#
+#     elif head in ['e', 'edit']:
+#         fn = action_edit
+#         args = {}
+#
+#     elif head in ['t', 'tag']:
+#         if not tail:
+#             helpful_exit('Please provide at least one tag to add.')
+#
+#         fn = action_tag
+#         args = {'tags': tail}
+#
+#     elif head in ['n', 'note']:
+#         if not tail:
+#             helpful_exit('Please provide some text to be noted.')
+#
+#         fn = action_note
+#         args = {'content': ' '.join(tail)}
+#
+#     elif head in ['i', 'interrupt']:
+#         if not tail:
+#             helpful_exit('Need the name of whatever you are working on.')
+#
+#         fn = action_interrupt
+#         args = {
+#             'name': tail[0],
+#             'time': to_datetime(' '.join(tail[1:])),
+#         }
+#
+#     else:
+#         helpful_exit("I don't understand '" + head + "'")
+#
+#     return fn, args
+
+
+# Inpired by Multi-level argparse by @chase_seibert
+# http://chase-seibert.github.io/blog/2014/03/21/python-multilevel-argparse.html
+class Ti(object):
+    valid_commands = {
+        'on': ['o', 'on'],
+        'fin': ['f', 'fin'],
+        'status': ['s', 'status'],
+        'log': ['l', 'log'],
+        'report': ['r', 'report'],
+    }
+    actions = None
+
+    def __init__(self):
+        self.actions = Actions()
+        parser = argparse.ArgumentParser(
+            usage=""" ti <command> [<args>]
+
+ti is a simple and extensible time tracker for the command line.
+Visit the project page (http://ti.sharats.me) for more details.
+
+Commands:
+  o, on        Start new tracking
+  f, fin       Stop currently running tracking
+  s, status    Show current status
+  l, log       List time logs for period with possible values today (default), week or month
+  r, report    Aggregated report for period with possible values today (default), week or month
+
+Old commands:
+  ti (t|tag) <tag>...
+  ti (n|note) <note-text>...
+
+  ti (e|edit)
+  ti (i|interrupt)
+  ti --no-color
+
+""")
+        parser.add_argument('command', help='Subcommand to run')
+        # parse_args defaults to [1:] for args, but you need to
+        # exclude the rest of the args too, or validation will fail
+        args = parser.parse_args(sys.argv[1:2])
+
+        reverse_map = {}
+        for k, v1 in self.valid_commands.items():
+            for v2 in v1:
+                reverse_map[v2] = k
+
+        if args.command not in reverse_map:
+            print('Unrecognized command')
+            parser.print_help()
+            exit(1)
+        getattr(self, reverse_map[args.command])()
+
+    def on(self):
+        parser = argparse.ArgumentParser(
+            prog='ti on',
+            description='Track new task')
+
+        parser.add_argument('task', type=str, nargs="?", help="name of task")
+        parser.add_argument('project', type=str, nargs="?", help="group task and tracking under project, "
+                                                                 "useful for aggregation")
+        parser.add_argument('--ago', type=str, metavar="time",
+                            help="shift start of tracking into past, eg. 10 minutes")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_on(**vars(args))
+
+    def fin(self):
+        parser = argparse.ArgumentParser(
+            prog='ti fin',
+            description='Finish running task')
+        parser.add_argument('--ago', type=str, metavar="time",
+                            help="shift finish of tracking into past, e.g. 10 minutes")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_fin(**vars(args))
+
+    def status(self):
+        parser = argparse.ArgumentParser(
+            prog='ti status',
+            description='Get current status')
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_status()
+
+    def log(self):
+        parser = argparse.ArgumentParser(
+            prog='ti log',
+            description='List of time logs for selected period')
+        parser.add_argument('period', type=str, metavar="time", nargs="?", default='today',
+                            choices=['today', 'week', 'month'],
+                            help="period of time, possible choices: today (default), week or month")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_log(**vars(args))
+
+    def report(self):
+        parser = argparse.ArgumentParser(
+            prog='ti report',
+            description='Aggregated report of time logs for selected period')
+        parser.add_argument('period', type=str, metavar="time", nargs="?", default='today',
+                            choices=['today', 'week', 'month'],
+                            help="period of time, possible choices: today (default), week or month")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_report(**vars(args))
+
+
+def main():
+    Ti()
+
+if __name__ == '__main__':
+    main()
diff --git a/ti/time_tracking.py b/ti/time_tracking.py
deleted file mode 100644
index 52ccccb..0000000
--- a/ti/time_tracking.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# coding: utf-8
-"""
-ti is a simple and extensible time tracker for the command line. Visit the
-project page (http://ti.sharats.me) for more details.
-
-Usage:
-  ti (o|on) <name> [<time>...]
-  ti (f|fin) [<time>...]
-  ti (s|status)
-  ti (t|tag) <tag>...
-  ti (n|note) <note-text>...
-  ti (l|log) [today]
-  ti (e|edit)
-  ti (i|interrupt)
-  ti --no-color
-  ti -h | --help
-
-Options:
-  -h --help         Show this help.
-  <start-time>...   A time specification (goto http://ti.sharats.me for more on
-                    this).
-  <tag>...          Tags can be made of any characters, but its probably a good
-                    idea to avoid whitespace.
-  <note-text>...    Some arbitrary text to be added as `notes` to the currently
-                    working project.
-"""
-
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import sys
-from .actions import action_edit, action_fin, action_interrupt, action_log, action_note, action_on, \
-    action_status, action_tag
-from .utils import to_datetime
-
-
-def helpful_exit(msg=__doc__):
-    print(msg, file=sys.stderr)
-    raise SystemExit
-
-
-def parse_args(argv=sys.argv):
-    use_color = False
-
-    argv = [arg for arg in argv]
-
-    if '--no-color' in argv:
-        use_color = False
-        argv.remove('--no-color')
-
-    # prog = argv[0]
-    if len(argv) == 1:
-        helpful_exit('You must specify a command.')
-
-    head = argv[1]
-    tail = argv[2:]
-
-    if head in ['-h', '--help', 'h', 'help']:
-        helpful_exit()
-
-    elif head in ['e', 'edit']:
-        fn = action_edit
-        args = {}
-
-    elif head in ['o', 'on']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_on
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    elif head in ['f', 'fin']:
-        fn = action_fin
-        args = {'time': to_datetime(' '.join(tail))}
-
-    elif head in ['s', 'status']:
-        fn = action_status
-        args = {}
-
-    elif head in ['l', 'log']:
-        fn = action_log
-        args = {'period': tail[0] if tail else None}
-
-    elif head in ['t', 'tag']:
-        if not tail:
-            helpful_exit('Please provide at least one tag to add.')
-
-        fn = action_tag
-        args = {'tags': tail}
-
-    elif head in ['n', 'note']:
-        if not tail:
-            helpful_exit('Please provide some text to be noted.')
-
-        fn = action_note
-        args = {'content': ' '.join(tail)}
-
-    elif head in ['i', 'interrupt']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_interrupt
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    else:
-        helpful_exit("I don't understand '" + head + "'")
-
-    return fn, args
-
-
-def main():
-    fn, args = parse_args()
-    fn(**args)
-
-
-if __name__ == '__main__':
-    main()

From f2c2cb18d754f6a12f6b2d3848f39a49501adada Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:17:34 +0200
Subject: [PATCH 07/18] Colors fixes, default is True

---
 ti/colors.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/ti/colors.py b/ti/colors.py
index 213e2c7..2facc75 100644
--- a/ti/colors.py
+++ b/ti/colors.py
@@ -2,28 +2,28 @@
 from colorama import Fore
 
 
-def red(_str, use_color=False):
+def red(_str, use_color=True):
     if use_color:
         return Fore.RED + _str + Fore.RESET
     else:
         return _str
 
 
-def green(_str, use_color=False):
+def green(_str, use_color=True):
     if use_color:
         return Fore.GREEN + _str + Fore.RESET
     else:
         return _str
 
 
-def yellow(_str, use_color=False):
+def yellow(_str, use_color=True):
     if use_color:
         return Fore.YELLOW + _str + Fore.RESET
     else:
         return _str
 
 
-def blue(_str, use_color=False):
+def blue(_str, use_color=True):
     if use_color:
         return Fore.BLUE + _str + Fore.RESET
     else:

From 88c00b468b0dccb2170150ba4fdddd98a8166124 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:18:31 +0200
Subject: [PATCH 08/18] Utils cleanup

---
 ti/utils.py | 147 +++++++++++++++++++++++++++++-----------------------
 1 file changed, 82 insertions(+), 65 deletions(-)

diff --git a/ti/utils.py b/ti/utils.py
index 74a68d1..f203612 100644
--- a/ti/utils.py
+++ b/ti/utils.py
@@ -2,68 +2,85 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
-import re
-from datetime import datetime, timedelta
-
-
-def to_datetime(timestr):
-    return parse_engtime(timestr).isoformat() + 'Z'
-
-
-def parse_engtime(timestr):
-
-    now = datetime.utcnow()
-    if not timestr or timestr.strip() == 'now':
-        return now
-
-    match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
-                     timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        seconds = 1 if n == 'a' else int(n)
-        return now - timedelta(seconds=seconds)
-
-    match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        minutes = 1 if n == 'a' else int(n)
-        return now - timedelta(minutes=minutes)
-
-    match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        hours = 1 if n in ['a', 'an'] else int(n)
-        return now - timedelta(hours=hours)
-
-    raise ValueError("Don't understand the time '" + timestr + "'")
-
-
-def parse_isotime(isotime):
-    return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
-
-
-def timegap(start_time, end_time):
-    diff = end_time - start_time
-
-    mins = diff.seconds / 60
-
-    if mins == 0:
-        return 'less than a minute'
-    elif mins == 1:
-        return 'a minute'
-    elif mins < 44:
-        return '{} minutes'.format(mins)
-    elif mins < 89:
-        return 'about an hour'
-    elif mins < 1439:
-        return 'about {} hours'.format(mins / 60)
-    elif mins < 2519:
-        return 'about a day'
-    elif mins < 43199:
-        return 'about {} days'.format(mins / 1440)
-    elif mins < 86399:
-        return 'about a month'
-    elif mins < 525599:
-        return 'about {} months'.format(mins / 43200)
-    else:
-        return 'more than a year'
+# import re
+# from datetime import datetime, timedelta
+import pendulum
+import math
+
+
+# def to_datetime(timestr):
+#     return parse_engtime(timestr).isoformat() + 'Z'
+#
+#
+# def parse_engtime(timestr):
+#
+#     now = datetime.utcnow()
+#     if not timestr or timestr.strip() == 'now':
+#         return now
+#
+#     match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
+#                      timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         seconds = 1 if n == 'a' else int(n)
+#         return now - timedelta(seconds=seconds)
+#
+#     match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         minutes = 1 if n == 'a' else int(n)
+#         return now - timedelta(minutes=minutes)
+#
+#     match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         hours = 1 if n in ['a', 'an'] else int(n)
+#         return now - timedelta(hours=hours)
+#
+#     raise ValueError("Don't understand the time '" + timestr + "'")
+#
+#
+# def parse_isotime(isotime):
+#     return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
+#
+#
+# def timegap(start_time, end_time):
+#     diff = end_time - start_time
+#
+#     mins = diff.seconds / 60
+#
+#     if mins == 0:
+#         return 'less than a minute'
+#     elif mins == 1:
+#         return 'a minute'
+#     elif mins < 44:
+#         return '{} minutes'.format(mins)
+#     elif mins < 89:
+#         return 'about an hour'
+#     elif mins < 1439:
+#         return 'about {} hours'.format(mins / 60)
+#     elif mins < 2519:
+#         return 'about a day'
+#     elif mins < 43199:
+#         return 'about {} days'.format(mins / 1440)
+#     elif mins < 86399:
+#         return 'about a month'
+#     elif mins < 525599:
+#         return 'about {} months'.format(mins / 43200)
+#     else:
+#         return 'more than a year'
+
+
+def seconds_to_hours_and_minutes(seconds):
+    ceil_seconds = math.ceil(seconds/60)*60
+    interval = pendulum.interval(seconds=ceil_seconds)
+
+    if interval.total_hours() > 24:
+        hours = math.floor(interval.total_hours())
+        minutes = interval.minutes
+        if minutes > 1:
+            return '{} hours {} minutes'.format(hours, minutes)
+        else:
+            return '{} hours {} minute'.format(hours, minutes)
+
+    return interval.__str__()

From a883b48f2d713a2249dba1682afc7b70cf265a52 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:19:13 +0200
Subject: [PATCH 09/18] Added .env to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 821089d..4f264e5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ __pycache__/
 *.so
 
 # Distribution / packaging
+/.env/
 .Python
 env/
 build/

From 0d9323fad34491f8a3b2c55fe782c2e7ff6d4dfd Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:19:41 +0200
Subject: [PATCH 10/18] Added git helper

---
 ti/git.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 ti/git.py

diff --git a/ti/git.py b/ti/git.py
new file mode 100644
index 0000000..671f95d
--- /dev/null
+++ b/ti/git.py
@@ -0,0 +1,32 @@
+# coding: utf-8
+import os.path
+import subprocess
+
+
+class Git(object):
+    path = '/usr/bin/git'
+
+    def is_git_installed(self):
+        return os.path.exists(self.path)
+
+    def is_cwd_repo(self):
+        return self.get_cmd_retcode(['git', 'rev-parse', 'HEAD']) == 0
+
+    def get_active_branch(self):
+        return self.get_cmd_retcode_and_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+
+    def get_top_level(self):
+        return self.get_cmd_retcode_and_output(['git', 'rev-parse', '--show-toplevel'])
+
+    def get_cmd_retcode(self, cmd):
+        devnull = open(os.devnull, 'w')
+        retcode = subprocess.call(cmd, stdout=devnull, stderr=subprocess.STDOUT)
+        return retcode
+
+    def get_cmd_retcode_and_output(self, cmd):
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+        output = process.communicate()[0]
+        retcode = process.returncode
+        if retcode == 0:
+            return output.decode('utf-8').strip()
+        return False

From 7d9ddbcf11230ad6bd490bcaaee3d80db7ea333c Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:20:15 +0200
Subject: [PATCH 11/18] Refactored actions with use of new multi argparse, git
 and Sqlite store

---
 ti/actions.py | 566 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 372 insertions(+), 194 deletions(-)

diff --git a/ti/actions.py b/ti/actions.py
index 167de86..11c6cce 100644
--- a/ti/actions.py
+++ b/ti/actions.py
@@ -11,205 +11,383 @@
 from collections import defaultdict
 from ti.colors import red, yellow, green
 from ti.utils import datetime, parse_isotime, timegap
-from ti import store
+# from ti import store
 from tabulate import tabulate
-
-
-def action_on(name, time):
-    data = store.load()
-    work = data['work']
-
-    if work and 'end' not in work[-1]:
-        print('You are already working on ' + yellow(work[-1]['name']) +
-              '. Stop it or use a different sheet.', file=sys.stderr)
-        raise SystemExit(1)
-
-    entry = {
-        'name': name,
-        'start': time,
-    }
-
-    work.append(entry)
-    store.dump(data)
-
-    print('Start working on ' + green(name) + '.')
-
-
-def action_fin(time, back_from_interrupt=True):
-    ensure_working()
-
-    data = store.load()
-
-    current = data['work'][-1]
-    current['end'] = time
-    store.dump(data)
-    print('So you stopped working on ' + red(current['name']) + '.')
-
-    if back_from_interrupt and len(data['interrupt_stack']) > 0:
-        name = data['interrupt_stack'].pop()['name']
-        store.dump(data)
-        action_on(name, time)
-        if len(data['interrupt_stack']) > 0:
-            print('You are now %d deep in interrupts.'
-                  % len(data['interrupt_stack']))
+from ti.store import Store
+from .git import Git
+import pendulum
+from pytimeparse.timeparse import timeparse
+from .utils import seconds_to_hours_and_minutes
+
+
+class Actions(object):
+    store = None
+    equal_to_last = {}
+    subtotals_count = 0
+    subtotals_sum = 0
+    subtotals_key = None
+
+    def __init__(self):
+        self.store = Store()
+
+    def action_on(self, task=None, project=None, ago=None):
+        git = Git()
+        git_support = git.is_git_installed() & git.is_cwd_repo()
+        # print('Is git installed: {}'.format(git.is_git_installed()))
+        # print('Is cwd git repo: {}'.format(git.is_cwd_repo()))
+        # print('Get top level: {}'.format(git.get_top_level()))
+        # print('Get current branch: {}'.format(git.get_active_branch()))
+
+        # project not set
+        if project is None:
+            if git_support:
+                project = os.path.basename(git.get_top_level())
+
+        if task is None:
+            if git_support:
+                task = git.get_active_branch()
+            else:
+                task = os.path.basename(os.getcwd())
+
+        now = pendulum.now()
+        time_text = 'right now'
+        verb_text = 'Starting'
+        if ago:
+            seconds_ago = timeparse(ago)
+            now = now.subtract(seconds=seconds_ago)
+            time_text = now.diff_for_humans()
+            verb_text = 'Started'
+
+        current = self.store.get_current()
+        if current:
+            print('You are already working on task {}. Stop it or use a different sheet.'.format(green(current['task'])),
+                  file=sys.stderr)
+            raise SystemExit(1)
+
+        self.store.add_tracking(task, project, now)
+
+        print('{} working on task {}{} {}.'.format(
+            verb_text,
+            green(task),
+            ' of project {}'.format(red(project)) if project else '',
+            yellow(time_text)
+        ))
+
+    # def action_fin(time, back_from_interrupt=True):
+    def action_fin(self, ago):
+        current = self.ensure_working()
+
+        now = pendulum.now()
+        if ago:
+            seconds_ago = timeparse(ago)
+            now = now.subtract(seconds=seconds_ago)
+
+        self.store.finish_tracking(current, now)
+        print('You were working on {}{} for {} and task is stopped now.'.format(
+            green(current['task']),
+            ' of project {}'.format(red(current['project'])) if current['project'] else '',
+            now.diff_for_humans(current['start'], absolute=True)
+        ))
+
+        # if back_from_interrupt and len(data['interrupt_stack']) > 0:
+        #     name = data['interrupt_stack'].pop()['name']
+        #     store.dump(data)
+        #     action_on(name, time)
+        #     if len(data['interrupt_stack']) > 0:
+        #         print('You are now %d deep in interrupts.'
+        #               % len(data['interrupt_stack']))
+        #     else:
+        #         print('Congrats, you\'re out of interrupts!')
+
+    def action_status(self):
+        current = self.ensure_working()
+        diff = pendulum.now().diff_for_humans(current['start'], absolute=True)
+        print('You have been working on {0} for {1}.'.format(
+            green(current['task']), diff))
+
+    def action_log(self, period):
+        now = pendulum.now()
+
+        data = []
+        headers = []
+        if period == 'today':
+            today = now.to_date_string()
+            results = self.store.get_logs(today, today)
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        start.format('%H:%M'),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'start',
+                    'end',
+                    'duration',
+                    'current',
+                ]
+        elif period == 'week':
+            results = self.store.get_logs(now.start_of('week').to_date_string(),
+                                          now.end_of('week').to_date_string())
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        self.none_if_equal_to_last('day_of_week', start.format('%A')),
+                        self.none_if_equal_to_last('start_date', start.format('%d%_t %b')),
+                        start.format('%H:%M'),
+                        self.none_if_equal_to_last('end_date', end.format('%d%_t %b')),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'day of week',
+                    'start',
+                    '',
+                    'end',
+                    '',
+                    'duration',
+                    'current',
+                ]
+        # period is month
         else:
-            print('Congrats, you\'re out of interrupts!')
-
-
-def action_interrupt(name, time):
-    ensure_working()
-
-    action_fin(time, back_from_interrupt=False)
-
-    data = store.load()
-    if 'interrupt_stack' not in data:
-        data['interrupt_stack'] = []
-    interrupt_stack = data['interrupt_stack']
-
-    interrupted = data['work'][-1]
-    interrupt_stack.append(interrupted)
-    store.dump(data)
-
-    action_on('interrupt: ' + green(name), time)
-    print('You are now %d deep in interrupts.' % len(interrupt_stack))
-
-
-def action_note(content):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    if 'notes' not in current:
-        current['notes'] = [content]
-    else:
-        current['notes'].append(content)
-
-    store.dump(data)
-
-    print('Yep, noted to ' + yellow(current['name']) + '.')
-
-
-def action_tag(tags):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    current['tags'] = set(current.get('tags') or [])
-    current['tags'].update(tags)
-    current['tags'] = list(current['tags'])
-
-    store.dump(data)
-
-    tag_count = str(len(tags))
-    print('Okay, tagged current work with ' + tag_count + ' tag' +
-          ('s' if tag_count > 1 else '') + '.')
-
-
-def action_status():
-    try:
-        ensure_working()
-    except SystemExit(1):
-        return
-
-    data = store.load()
-    current = data['work'][-1]
-
-    start_time = parse_isotime(current['start'])
-    diff = timegap(start_time, datetime.utcnow())
-
-    print('You have been working on {0} for {1}.'.format(
-        green(current['name']), diff))
-
-
-def action_log(period):
-    data = store.load()
-    work = data['work'] + data['interrupt_stack']
-    log = defaultdict(lambda: {'delta': timedelta()})
-    current = None
-
-    for item in work:
-        start_time = parse_isotime(item['start'])
-        if 'end' in item:
-            log[item['name']]['delta'] += (
-                parse_isotime(item['end']) - start_time)
+            results = self.store.get_logs(now.start_of('month').to_date_string(),
+                                          now.end_of('month').to_date_string())
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        self.none_if_equal_to_last('day_of_week', start.format('%A')),
+                        self.none_if_equal_to_last('start_date', start.format('%d%_t %b')),
+                        start.format('%H:%M'),
+                        self.none_if_equal_to_last('end_date', end.format('%d%_t %b')),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'day of week',
+                    'start',
+                    '',
+                    'end',
+                    '',
+                    'duration',
+                    'current',
+                ]
+        print('\n' + tabulate(data, headers=headers))
+
+    def action_report(self, period):
+        now = pendulum.now()
+
+        if period == 'today':
+            today = now.to_date_string()
+            results = self.store.get_aggregated_logs(today, today)
+
+        elif period == 'week':
+            results = self.store.get_aggregated_logs(now.start_of('week').to_date_string(),
+                                                     now.end_of('week').to_date_string())
+
+        # period is month
         else:
-            log[item['name']]['delta'] += datetime.utcnow() - start_time
-            current = item['name']
-
-    for name, item in log.items():
-        secs = item['delta'].seconds
-        tmsg = []
-
-        if secs > 3600:
-            hours = int(secs / 3600)
-            secs -= hours * 3600
-            tmsg.append(str(hours) + ' hour' + ('s' if hours > 1 else ''))
-
-        if secs > 60:
-            mins = int(secs / 60)
-            secs -= mins * 60
-            tmsg.append(str(mins) + ' minute' + ('s' if mins > 1 else ''))
-
-        if secs:
-            tmsg.append(str(secs) + ' second' + ('s' if secs > 1 else ''))
-
-        log[name]['tmsg'] = ', '.join(tmsg)[::-1].replace(',', '& ', 1)[::-1]
-
-    log_list = []
-    for name, item in log.items():
-        log_list.append(
+            results = self.store.get_aggregated_logs(now.start_of('month').to_date_string(),
+                                                     now.end_of('month').to_date_string())
+
+        data = []
+        headers = [
+            'project',
+            'task',
+            'task total',
+            'project total',
+            'total'
+        ]
+        total = 0
+        for log in results:
+            total += log['total_seconds']
+            subtotals = self.subtotals(log['project'], log['total_seconds'])
+            if subtotals:
+                data.append(
+                    (
+                        '-',
+                        '-',
+                        '-',
+                        seconds_to_hours_and_minutes(subtotals),
+                        ''
+                    )
+                )
+            data.append(
+                (
+                    self.none_if_equal_to_last('project', log['project']),
+                    log['task'],
+                    seconds_to_hours_and_minutes(log['total_seconds']),
+                    '',
+                    ''
+                )
+            )
+        # project subtotals
+        subtotals = self.subtotals('', 0)
+        if subtotals:
+            data.append(
+                (
+                    '-',
+                    '-',
+                    '-',
+                    seconds_to_hours_and_minutes(subtotals),
+                    ''
+                )
+            )
+        # totals
+        data.append(
             (
-                name,
-                item['tmsg'],
-                ' ← working' if current == name else ''
+                '',
+                '',
+                '',
+                '',
+                seconds_to_hours_and_minutes(total)
             )
         )
-    data = sorted(log_list, key=lambda x: x[0], reverse=True)
-    print(tabulate(data))
-
-
-def action_edit():
-    if 'EDITOR' not in os.environ:
-        print("Please set the 'EDITOR' environment variable", file=sys.stderr)
-        raise SystemExit(1)
+        print('\n' + tabulate(data, headers=headers, tablefmt='simple'))
+
+    # def action_interrupt(name, time):
+    #     ensure_working()
+    #
+    #     action_fin(time, back_from_interrupt=False)
+    #
+    #     data = store.load()
+    #     if 'interrupt_stack' not in data:
+    #         data['interrupt_stack'] = []
+    #     interrupt_stack = data['interrupt_stack']
+    #
+    #     interrupted = data['work'][-1]
+    #     interrupt_stack.append(interrupted)
+    #     store.dump(data)
+    #
+    #     action_on('interrupt: ' + green(name), time)
+    #     print('You are now %d deep in interrupts.' % len(interrupt_stack))
+    #
+    #
+    # def action_note(content):
+    #     ensure_working()
+    #
+    #     data = store.load()
+    #     current = data['work'][-1]
+    #
+    #     if 'notes' not in current:
+    #         current['notes'] = [content]
+    #     else:
+    #         current['notes'].append(content)
+    #
+    #     store.dump(data)
+    #
+    #     print('Yep, noted to ' + yellow(current['name']) + '.')
+    #
+    #
+    # def action_tag(tags):
+    #     ensure_working()
+    #
+    #     data = store.load()
+    #     current = data['work'][-1]
+    #
+    #     current['tags'] = set(current.get('tags') or [])
+    #     current['tags'].update(tags)
+    #     current['tags'] = list(current['tags'])
+    #
+    #     store.dump(data)
+    #
+    #     tag_count = str(len(tags))
+    #     print('Okay, tagged current work with ' + tag_count + ' tag' +
+    #           ('s' if tag_count > 1 else '') + '.')
+    #
+    #
+    # def action_edit():
+    #     if 'EDITOR' not in os.environ:
+    #         print("Please set the 'EDITOR' environment variable", file=sys.stderr)
+    #         raise SystemExit(1)
+    #
+    #     data = store.load()
+    #     yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
+    #
+    #     cmd = os.getenv('EDITOR')
+    #     fd, temp_path = tempfile.mkstemp(prefix='ti.')
+    #     with open(temp_path, "r+") as f:
+    #         f.write(yml.replace('\n- ', '\n\n- '))
+    #         f.seek(0)
+    #         subprocess.check_call(cmd + ' ' + temp_path, shell=True)
+    #         yml = f.read()
+    #         f.truncate()
+    #         f.close()
+    #
+    #     os.close(fd)
+    #     os.remove(temp_path)
+    #
+    #     try:
+    #         data = yaml.load(yml)
+    #     except:
+    #         print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
+    #         raise SystemExit(1)
+    #
+    #     store.dump(data)
+    #
+    # def is_working():
+    #     data = store.load()
+    #     return data.get('work') and 'end' not in data['work'][-1]
+
+    def none_if_equal_to_last(self, key, value):
+        if key in self.equal_to_last and self.equal_to_last[key] == value:
+            return '-'
 
-    data = store.load()
-    yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
-
-    cmd = os.getenv('EDITOR')
-    fd, temp_path = tempfile.mkstemp(prefix='ti.')
-    with open(temp_path, "r+") as f:
-        f.write(yml.replace('\n- ', '\n\n- '))
-        f.seek(0)
-        subprocess.check_call(cmd + ' ' + temp_path, shell=True)
-        yml = f.read()
-        f.truncate()
-        f.close()
-
-    os.close(fd)
-    os.remove(temp_path)
-
-    try:
-        data = yaml.load(yml)
-    except:
-        print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
+        else:
+            self.equal_to_last[key] = value
+            return value
+
+    def subtotals(self, key, seconds):
+        sum = False
+        if key != self.subtotals_key:
+            if self.subtotals_count > 1:
+                sum = self.subtotals_sum
+            self.subtotals_sum = seconds
+            self.subtotals_key = key
+            self.subtotals_count = 1
+            return sum
+
+        self.subtotals_sum += seconds
+        self.subtotals_count += 1
+        return sum
+
+    def ensure_working(self):
+        current = self.store.get_current()
+        if current:
+            return current
+
+        print("For all I know, you aren't working on anything. "
+              "I don't know what to do.", file=sys.stderr)
+        print('See `ti -h` to know how to start working.', file=sys.stderr)
         raise SystemExit(1)
-
-    store.dump(data)
-
-
-def is_working():
-    data = store.load()
-    return data.get('work') and 'end' not in data['work'][-1]
-
-
-def ensure_working():
-    if is_working():
-        return
-
-    print("For all I know, you aren't working on anything. "
-          "I don't know what to do.", file=sys.stderr)
-    print('See `ti -h` to know how to start working.', file=sys.stderr)
-    raise SystemExit(1)

From 7971d0c0b60c5a8b2f1ee52ef3078451a3c3ba0f Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:21:03 +0200
Subject: [PATCH 12/18] setup.py: fixed install requirements

---
 setup.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 5cf6e07..cb3467e 100755
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,9 @@ def read(*filenames, **kwargs):
     install_requires=[
         "colorama",
         "PyYAML",
-        "tabulate"
+        "tabulate",
+        "pendulum>=0.5.0",
+        "pytimeparse",
     ],
     setup_requires=["pytest-runner"] if testing else [],
     tests_require=["pytest", "cram", "pytest-cram"],

From dae4f366657ef3623f3fe48ee13726916dc60685 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:23:45 +0200
Subject: [PATCH 13/18] setup.py: updated autors and webpage

---
 setup.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/setup.py b/setup.py
index cb3467e..0992013 100755
--- a/setup.py
+++ b/setup.py
@@ -19,12 +19,12 @@ def read(*filenames, **kwargs):
 setup(
     name="ti",
     version=ti.__version__,
-    author="Shrikant Sharat",
-    author_email="shrikantsharat.k@gmail.com",
+    author="Shrikant Sharat, Trevor Bekolay, Eduard Kracmar",
+    author_email="shrikantsharat.k@gmail.com, tbekolay@gmail.com, eduard@adaptiware.com",
     packages=find_packages(),
     include_package_data=True,
     scripts=[],
-    url="http://ti.sharats.me/",
+    url="https://github.com/tbekolay/ti",
     description="A silly simple time tracker",
     long_description=read('README.rst', 'CHANGES.rst'),
     entry_points={

From 7a968acaa581d871bf44274e113683215a1dbcf3 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:32:49 +0200
Subject: [PATCH 14/18] v0.1.1.dev2

---
 ti/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ti/__init__.py b/ti/__init__.py
index 8c354f8..1d4f2cd 100755
--- a/ti/__init__.py
+++ b/ti/__init__.py
@@ -2,7 +2,7 @@
 import os
 import json
 
-__version__ = '0.1.1.dev1'
+__version__ = '0.1.1.dev2'
 
 
 class JsonStore(object):

From 87bca42f55abf4b5c47bb4eb8c4c9e66bf2b87d8 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 13:39:04 +0200
Subject: [PATCH 15/18] Action imports cleanup

---
 ti/actions.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/ti/actions.py b/ti/actions.py
index 11c6cce..ea8b240 100644
--- a/ti/actions.py
+++ b/ti/actions.py
@@ -2,21 +2,19 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+import pendulum
 import yaml
 import os
 import subprocess
 import sys
 import tempfile
+from pytimeparse.timeparse import timeparse
 from datetime import timedelta
 from collections import defaultdict
-from ti.colors import red, yellow, green
-from ti.utils import datetime, parse_isotime, timegap
-# from ti import store
 from tabulate import tabulate
-from ti.store import Store
+from .store import Store
 from .git import Git
-import pendulum
-from pytimeparse.timeparse import timeparse
+from .colors import red, yellow, green
 from .utils import seconds_to_hours_and_minutes
 
 

From fb530050811a5f4871b643648682fb5e78ec7a61 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 15:41:01 +0200
Subject: [PATCH 16/18] Added status --short

---
 ti/actions.py | 32 +++++++++++++++++++++++---------
 ti/ti.py      |  4 +++-
 2 files changed, 26 insertions(+), 10 deletions(-)

diff --git a/ti/actions.py b/ti/actions.py
index ea8b240..219cd42 100644
--- a/ti/actions.py
+++ b/ti/actions.py
@@ -97,11 +97,23 @@ def action_fin(self, ago):
         #     else:
         #         print('Congrats, you\'re out of interrupts!')
 
-    def action_status(self):
-        current = self.ensure_working()
-        diff = pendulum.now().diff_for_humans(current['start'], absolute=True)
-        print('You have been working on {0} for {1}.'.format(
-            green(current['task']), diff))
+    def action_status(self, short):
+        try:
+            current = self.ensure_working(silent=short)
+
+            diff = pendulum.now().diff_for_humans(current['start'], absolute=True)
+            if short:
+                print('on {}/{} for {}.'.format(
+                    red(current['project']),
+                    green(current['task']),
+                    diff))
+            else:
+                print('You have been working on {0} for {1}.'.format(
+                    green(current['task']), diff))
+
+        except SystemExit:
+            if short:
+                print('idle')
 
     def action_log(self, period):
         now = pendulum.now()
@@ -380,12 +392,14 @@ def subtotals(self, key, seconds):
         self.subtotals_count += 1
         return sum
 
-    def ensure_working(self):
+    def ensure_working(self, silent=False):
         current = self.store.get_current()
         if current:
             return current
 
-        print("For all I know, you aren't working on anything. "
-              "I don't know what to do.", file=sys.stderr)
-        print('See `ti -h` to know how to start working.', file=sys.stderr)
+        if not silent:
+            print("For all I know, you aren't working on anything. "
+                  "I don't know what to do.", file=sys.stderr)
+            print('See `ti -h` to know how to start working.', file=sys.stderr)
+
         raise SystemExit(1)
diff --git a/ti/ti.py b/ti/ti.py
index 4dbb66d..ac8d87a 100644
--- a/ti/ti.py
+++ b/ti/ti.py
@@ -142,9 +142,11 @@ def status(self):
         parser = argparse.ArgumentParser(
             prog='ti status',
             description='Get current status')
+        parser.add_argument('--short', default=False, action="store_true",
+                            help="short status ideal for integration to other tools e.g. bash prompt")
 
         args = parser.parse_args(sys.argv[2:])
-        self.actions.action_status()
+        self.actions.action_status(**vars(args))
 
     def log(self):
         parser = argparse.ArgumentParser(

From 85a8843e9697672837e2810d1d9af952159345f4 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Tue, 30 Aug 2016 17:24:20 +0200
Subject: [PATCH 17/18] While in git repo, project as git top level replaced
 with full path to repo (more descriptive)

---
 ti/actions.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ti/actions.py b/ti/actions.py
index 219cd42..548e289 100644
--- a/ti/actions.py
+++ b/ti/actions.py
@@ -39,7 +39,8 @@ def action_on(self, task=None, project=None, ago=None):
         # project not set
         if project is None:
             if git_support:
-                project = os.path.basename(git.get_top_level())
+                project_path = git.get_top_level()[1:]
+                project = str(project_path).replace('/', '-')
 
         if task is None:
             if git_support:

From b22fd2769a519e599f94305c2469b096eef6b9f2 Mon Sep 17 00:00:00 2001
From: Eduard Kracmar <eduard@adaptiware.com>
Date: Wed, 31 Aug 2016 06:20:14 +0200
Subject: [PATCH 18/18] Limiting pendulum to 0.5.2 found bug with latest 0.5.4

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 0992013..e1565b2 100755
--- a/setup.py
+++ b/setup.py
@@ -36,7 +36,7 @@ def read(*filenames, **kwargs):
         "colorama",
         "PyYAML",
         "tabulate",
-        "pendulum>=0.5.0",
+        "pendulum==0.5.2",
         "pytimeparse",
     ],
     setup_requires=["pytest-runner"] if testing else [],