Merge lp:~jonatan-cloutier/gtimelog/addTags into lp:~gtimelog-dev/gtimelog/trunk

[Jonatan Cloutier]

Add a tagging feature

Unmerged revisions

255. By Jonatan Cloutier on 2013-02-16

add tags feature

=== modified file 'src/gtimelog/gtimelog.ui'
--- src/gtimelog/gtimelog.ui	2012-08-23 05:20:13 +0000
+++ src/gtimelog/gtimelog.ui	2013-03-15 14:20:28 +0000
@@ -292,6 +292,18 @@
                       </object>
                     </child>
                     <child>
+                      <object class="GtkRadioMenuItem" id="tags">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="use_action_appearance">False</property>
+                        <property name="label" translatable="yes">T_ags</property>
+                        <property name="use_underline">True</property>
+                        <property name="group">chronological</property>
+                        <accelerator key="4" signal="activate" modifiers="GDK_MOD1_MASK"/>
+                        <signal name="activate" handler="on_tags_activate" swapped="no"/>
+                      </object>
+                    </child>
+                    <child>
                       <object class="GtkSeparatorMenuItem" id="separator2">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>

=== modified file 'src/gtimelog/main.py'
--- src/gtimelog/main.py	2013-02-07 08:33:21 +0000
+++ src/gtimelog/main.py	2013-03-15 14:20:28 +0000
@@ -350,7 +350,7 @@
         duration = stop - start
         return start, stop, duration, entry
 
-    def grouped_entries(self, skip_first=True):
+    def grouped_entries(self, skip_first=True, trimTags=True):
         """Return consolidated entries (grouped by entry title).
 
         Returns two list: work entries and slacking entries.  Slacking
@@ -360,6 +360,8 @@
         work = {}
         slack = {}
         for start, stop, duration, entry in self.all_entries():
+            if trimTags:
+                entry = entry.split(" '")[0]
             if skip_first:
                 skip_first = False
                 continue
@@ -411,6 +413,35 @@
                     None, datetime.timedelta(0)) + duration
         return entries, totals
 
+    def tagged_work_entries(self, skip_first=True):
+        """Return consolidated work entries grouped by tag.
+
+        Tag is a string following an apostrophe (') at the end of an entry.
+
+        Return two dicts:
+          - {<tag>: <entry list>}, where <tag> is a tag string
+            and <entry list> is a sorted list that contains tuples (start,
+            entry, duration); entry is stripped of its tag. An entry can
+            be present in more than one tag.
+          - {<tag>: <total duration>}, where <total duration> is the
+            total duration of work in the <category>.
+        """
+
+        work, slack = self.grouped_entries(skip_first=skip_first, trimTags=False)
+        entries = {}
+        totals = {}
+        for start, entry, duration in work:
+            if " '" in entry:
+                splitedEntries = entry.split(" '")
+                tags = splitedEntries[1:]
+                clipped_entry = splitedEntries[0]
+                for tag in tags:
+                    entry_list = entries.get(tag, [])
+                    entry_list.append((start, clipped_entry, duration))
+                    entries[tag] = entry_list
+                    totals[tag] = totals.get(tag, datetime.timedelta(0)) + duration
+        return entries, totals
+
     def totals(self):
         """Calculate total time of work and slacking entries.
 
@@ -637,8 +668,31 @@
         print >> output
         print >> output, "By category:"
         print >> output
-
-        items = categories.items()
+        
+        self._report_groups(output, categories)
+
+    def _report_tags(self, output, tags):
+        """A helper method that lists time spent per tag.
+
+        Use this to add a section in a report looks similar to this:
+
+        Administration:  2 hours 1 min
+        Coding:          18 hours 45 min
+        Learning:        3 hours
+
+        tags is a dict of entries (<tag name>: <duration>).
+        """
+        print >> output
+        print >> output, "By tag:"
+        print >> output
+        
+        self._report_groups(output, tags)
+        
+    def _report_groups(self, output, groups):
+        """A helper method that lists time spent per grouped entries,
+         either categories or tags.
+        """
+        items = groups.items()
         items.sort()
         for cat, duration in items:
             if not cat:
@@ -647,9 +701,9 @@
             print >> output, u"%-62s  %s" % (
                 cat, format_duration_long(duration))
 
-        if None in categories:
+        if None in groups:
             print >> output, u"%-62s  %s" % (
-                '(none)', format_duration_long(categories[None]))
+                '(none)', format_duration_long(groups[None]))
         print >> output
 
     def _plain_report(self, output, email, who, subject, period_name,
@@ -674,7 +728,6 @@
             print >> output, "                time"
         work, slack = window.grouped_entries()
         total_work, total_slacking = window.totals()
-        categories = {}
         if work:
             work = [(entry, duration) for start, entry, duration in work]
             work.sort()
@@ -682,14 +735,6 @@
                 if not duration:
                     continue # skip empty "arrival" entries
 
-                if ': ' in entry:
-                    cat, task = entry.split(': ', 1)
-                    categories[cat] = categories.get(
-                        cat, datetime.timedelta(0)) + duration
-                else:
-                    categories[None] = categories.get(
-                        None, datetime.timedelta(0)) + duration
-
                 entry = entry[:1].upper() + entry[1:]
                 if estimated_column:
                     print >> output, (u"%-46s  %-14s  %s" %
@@ -701,9 +746,14 @@
         print >> output, ("Total work done this %s: %s" %
                           (period_name, format_duration_long(total_work)))
 
+        entries, categories = window.categorized_work_entries()
         if categories:
             self._report_categories(output, categories)
 
+        entries, tags = window.tagged_work_entries()
+        if tags:
+            self._report_tags(output, tags)
+
     def weekly_report_categorized(self, output, email, who,
                                   estimated_column=False):
         """Format a weekly report with entries displayed  under categories."""
@@ -766,27 +816,24 @@
         print >> output
         work, slack = window.grouped_entries()
         total_work, total_slacking = window.totals()
-        categories = {}
         if work:
             for start, entry, duration in work:
                 entry = entry[:1].upper() + entry[1:]
                 print >> output, u"%-62s  %s" % (entry,
                                                 format_duration_long(duration))
-                if ': ' in entry:
-                    cat, task = entry.split(': ', 1)
-                    categories[cat] = categories.get(
-                        cat, datetime.timedelta(0)) + duration
-                else:
-                    categories[None] = categories.get(
-                        None, datetime.timedelta(0)) + duration
 
             print >> output
         print >> output, ("Total work done: %s" %
                           format_duration_long(total_work))
 
-        if len(categories) > 0:
+        entries, categories = window.categorized_work_entries()
+        if categories:
             self._report_categories(output, categories)
 
+        entries, tags = window.tagged_work_entries()
+        if tags:
+            self._report_tags(output, tags)
+
         print >> output, 'Slacking:\n'
 
         if slack:
@@ -1053,6 +1100,7 @@
     spreadsheet = 'xdg-open %s'
     chronological = True
     summary_view = False
+    tags_view = False
     show_tasks = True
 
     enable_gtk_completion = True  # False enables gvim-style completion
@@ -1111,6 +1159,7 @@
         config.set('gtimelog', 'spreadsheet', self.spreadsheet)
         config.set('gtimelog', 'chronological', str(self.chronological))
         config.set('gtimelog', 'summary_view', str(self.summary_view))
+        config.set('gtimelog', 'tags_view', str(self.tags_view))
         config.set('gtimelog', 'show_tasks', str(self.show_tasks))
         config.set('gtimelog', 'gtk-completion',
                    str(self.enable_gtk_completion))
@@ -1140,6 +1189,7 @@
         self.spreadsheet = config.get('gtimelog', 'spreadsheet')
         self.chronological = config.getboolean('gtimelog', 'chronological')
         self.summary_view = config.getboolean('gtimelog', 'summary_view')
+        self.tags_view = config.getboolean('gtimelog', 'tags_view')
         self.show_tasks = config.getboolean('gtimelog', 'show_tasks')
         self.enable_gtk_completion = config.getboolean('gtimelog',
                                                        'gtk-completion')
@@ -1440,6 +1490,7 @@
         self.chronological = (settings.chronological
                               and not settings.summary_view)
         self.summary_view = settings.summary_view
+        self.tags_view = settings.tags_view
         self.show_tasks = settings.show_tasks
         self.looking_at_date = None
         self.entry_watchers = []
@@ -1454,6 +1505,8 @@
         chronological_menu_item.set_active(self.chronological)
         summary_menu_item = builder.get_object('summary')
         summary_menu_item.set_active(self.summary_view)
+        tags_menu_item = builder.get_object('tags')
+        tags_menu_item.set_active(self.tags_view)
         show_task_pane_item = builder.get_object('show_task_pane')
         show_task_pane_item.set_active(self.show_tasks)
         # Now hook up signals.
@@ -1568,6 +1621,13 @@
             where = buffer.get_end_iter()
             where.backward_cursor_position()
             buffer.place_cursor(where)
+        elif self.tags_view:
+            entries, totals = window.tagged_work_entries()
+            for category, duration in sorted(totals.items()):
+                self.write_group(category or 'no category', duration)
+            where = buffer.get_end_iter()
+            where.backward_cursor_position()
+            buffer.place_cursor(where)
         else:
             work, slack = window.grouped_entries()
             for start, entry, duration in work + slack:
@@ -1830,18 +1890,28 @@
         """View -> Chronological"""
         self.chronological = True
         self.summary_view = False
+        self.tags_view = False
         self.populate_log()
 
     def on_grouped_activate(self, widget):
         """View -> Grouped"""
         self.chronological = False
         self.summary_view = False
+        self.tags_view = False
         self.populate_log()
 
     def on_summary_activate(self, widget):
         """View -> Summary"""
         self.chronological = False
         self.summary_view = True
+        self.tags_view = False
+        self.populate_log()
+
+    def on_tags_activate(self, widget):
+        """View -> Tags"""
+        self.chronological = False
+        self.summary_view = False
+        self.tags_view = True
         self.populate_log()
 
     def daily_window(self, day=None):