Merge pull request #44 from schwuk/comment-subscriptions

Extract comment subscriptions as their own module

Author: nb

README.md

@@ -24,6 +24,22 @@ your `plugins` directory.
 
 Trac Code Comments plugin requres at least python 2.4 and runs on Trac 0.12.
 
+Enable all the modules through the admin web UI or by editing `trac.ini`.
+
+
+Upgrading
+---------
+
+Install the latest version of the plugin (as above).
+
+Run `trac-admin <path-to-environment> upgrade` to update the database.
+
+Enable any new modules through the admin web UI or by editing `trac.ini`.
+
+Run `trac-admin <path-to-environment> subscription seed` to create
+subsriptionfor existing attachments, changesets and comments.
+
+
 Features
 --------
 
@@ -54,6 +70,9 @@ tickets and which are not.
 * Notifications – if you have configured Trac to email ticket notifications
 then comment notifications will just work!
 
+ * Subscriptions – Authors of changesets and attachments, and anyone who
+creates a comment are subscribed to notifications of comments; to have changeset authors automatically subscribed, your repositories must be configured for [synchronisation](http://trac.edgewall.org/wiki/TracRepositoryAdmin#Synchronization) with Trac
+
 Screenshots
 -----------
 

code_comments/__init__.py

@@ -1,7 +1,8 @@
 from code_comments import comment
+from code_comments import comment_macro
 from code_comments import comments
 from code_comments import db
 from code_comments import notification
-from code_comments import web
-from code_comments import comment_macro
+from code_comments import subscription
 from code_comments import ticket_event_listener
+from code_comments import web

code_comments/db.py

@@ -1,10 +1,10 @@
-from trac.core import *
+from trac.core import Component, implements
 from trac.db.schema import Table, Column, Index
 from trac.env import IEnvironmentSetupParticipant
 from trac.db.api import DatabaseManager
 
 # Database version identifier for upgrades.
-db_version = 2
+db_version = 3
 
 # Database schema
 schema = {
@@ -21,61 +21,91 @@
         Index(['path']),
         Index(['author']),
     ],
+    'code_comments_subscriptions': Table('code_comments_subscriptions',
+                                         key=('id', 'user', 'type', 'path',
+                                              'repos', 'rev'))[
+        Column('id', auto_increment=True),
+        Column('user'),
+        Column('type'),
+        Column('path'),
+        Column('repos'),
+        Column('rev'),
+        Column('notify', type='bool'),
+        Index(['user']),
+        Index(['path']),
+    ],
 }
 
+
 def to_sql(env, table):
     """ Convenience function to get the to_sql for the active connector."""
     dc = DatabaseManager(env)._get_connector()[0]
     return dc.to_sql(table)
 
+
 def create_tables(env, db):
     cursor = db.cursor()
     for table_name in schema:
         for stmt in to_sql(env, schema[table_name]):
             cursor.execute(stmt)
-    cursor.execute("INSERT into system values ('code_comments_schema_version', %s)",
-                        str(db_version))
+    cursor.execute(
+        "INSERT INTO system VALUES ('code_comments_schema_version', %s)",
+        str(db_version))
+
 
 # Upgrades
+
 def upgrade_from_1_to_2(env, db):
     # Add the new column "type"
     @env.with_transaction()
-    def add_type_column( db ):
+    def add_type_column(db):
         cursor = db.cursor()
-        cursor.execute( 'ALTER TABLE code_comments ADD COLUMN type TEXT' )
+        cursor.execute('ALTER TABLE code_comments ADD COLUMN type TEXT')
 
     # Convert all the current comments to the new schema
     @env.with_transaction()
-    def convert_comments( db ):
+    def convert_comments(db):
         comments = {}
         cursor = db.cursor()
-        cursor.execute( 'SELECT id, path FROM code_comments' )
+        cursor.execute('SELECT id, path FROM code_comments')
         comments = cursor.fetchall()
         # options:
         # 1: comment on file (path != "" && path != "attachment")
         # 2: comment on changeset (path == "")
         # 3: comment on attachment (path == "attachment")
         for comment in comments:
             path = comment[1]
-            is_comment_to_attachment = path.startswith( 'attachment' )
+            is_comment_to_attachment = path.startswith('attachment')
             is_comment_to_file = not is_comment_to_attachment and '' != path
             is_comment_to_changeset = '' == path
             cursor = db.cursor()
             update = 'UPDATE code_comments SET type={0} WHERE id={1}'
             sql = ''
 
             if is_comment_to_changeset:
-                sql = update.format( "'changeset'", str( comment[0] ) )
+                sql = update.format("'changeset'", str(comment[0]))
             elif is_comment_to_attachment:
-                sql = update.format( "'attachment'", str(comment[0] ) )
+                sql = update.format("'attachment'", str(comment[0]))
             elif is_comment_to_file:
-                sql = update.format( "'browser'", str(comment[0] ) )
+                sql = update.format("'browser'", str(comment[0]))
+
+            cursor.execute(sql)
+
+
+def upgrade_from_2_to_3(env, db):
+    # Add the new table
+    @env.with_transaction()
+    def add_subscriptions_table(db):
+        cursor = db.cursor()
+        for stmt in to_sql(env, schema['code_comments_subscriptions']):
+            cursor.execute(stmt)
 
-            cursor.execute( sql )
 
 upgrade_map = {
-        2: upgrade_from_1_to_2
-    }
+    2: upgrade_from_1_to_2,
+    3: upgrade_from_2_to_3,
+}
+
 
 class CodeCommentsSetup(Component):
     """Component that deals with database setup and upgrades."""
@@ -87,13 +117,17 @@ def environment_created(self):
         pass
 
     def environment_needs_upgrade(self, db):
-        """Called when Trac checks whether the environment needs to be upgraded.
-        Returns `True` if upgrade is needed, `False` otherwise."""
+        """
+        Called when Trac checks whether the environment needs to be upgraded.
+        Returns `True` if upgrade is needed, `False` otherwise.
+        """
         return self._get_version(db) != db_version
 
     def upgrade_environment(self, db):
-        """Actually perform an environment upgrade, but don't commit as
-        that is done by the common upgrade procedure when all plugins are done."""
+        """
+        Actually perform an environment upgrade, but don't commit as
+        that is done by the common upgrade procedure when all plugins are done.
+        """
         current_ver = self._get_version(db)
         if current_ver == 0:
             create_tables(self.env, db)
@@ -102,8 +136,9 @@ def upgrade_environment(self, db):
                 upgrade_map[current_ver+1](self.env, db)
                 current_ver += 1
             cursor = db.cursor()
-            cursor.execute("UPDATE system SET value=%s WHERE name='code_comments_schema_version'",
-                                str(db_version))
+            cursor.execute(
+                "UPDATE system SET value=%s WHERE name='code_comments_schema_version'",
+                str(db_version))
 
     def _get_version(self, db):
         cursor = db.cursor()

code_comments/notification.py

@@ -1,11 +1,10 @@
-from trac.attachment import Attachment
 from trac.config import BoolOption
 from trac.core import Component, implements
 from trac.notification import NotifyEmail
-from trac.resource import ResourceNotFound
-from trac.versioncontrol import RepositoryManager, NoSuchChangeset
+
 from code_comments.api import ICodeCommentChangeListener
 from code_comments.comments import Comments
+from code_comments.subscription import Subscription
 
 
 class CodeCommentChangeListener(Component):
@@ -33,41 +32,6 @@ class CodeCommentNotifyEmail(NotifyEmail):
     template_name = "code_comment_notify_email.txt"
     from_email = "trac+comments@localhost"
 
-    def _get_attachment_author(self, parent, parent_id, filename):
-        """
-        Returns the author of a given attachment.
-        """
-        try:
-            attachment = Attachment(self.env, parent, parent_id, filename)
-            return attachment.author
-        except ResourceNotFound:
-            self.env.log.debug("Invalid attachment, unable to determine "
-                               "author.")
-
-    def _get_changeset_author(self, revision, reponame=None):
-        """
-        Returns the author of a changeset for a given revision.
-        """
-        try:
-            repos = RepositoryManager(self.env).get_repository(reponame)
-            changeset = repos.get_changeset(revision)
-            return changeset.author
-        except NoSuchChangeset:
-            self.env.log.debug("Invalid changeset, unable to determine author")
-
-    def _get_original_author(self, comment):
-        """
-        Returns the author for the target of a given comment.
-        """
-        if comment.type == 'attachment':
-            parent, parent_id, filename = comment.path.split("/")[1:]
-            return self._get_attachment_author(parent, parent_id,
-                                               filename)
-        elif (comment.type == 'changeset' or comment.type == "browser"):
-            # TODO: When support is added for multiple repositories, this
-            # will need updated
-            return self._get_changeset_author(comment.revision)
-
     def _get_comment_thread(self, comment):
         """
         Returns all comments in the same location as a given comment, sorted
@@ -80,16 +44,6 @@ def _get_comment_thread(self, comment):
                 'line': comment.line}
         return comments.search(args, order_by='id')
 
-    def _get_commenters(self, comment):
-        """
-        Returns a list of all commenters for the same thing.
-        """
-        comments = Comments(None, self.env)
-        args = {'type': comment.type,
-                'revision': comment.revision,
-                'path': comment.path}
-        return comments.get_all_comment_authors(comments.search(args))
-
     def get_recipients(self, comment):
         """
         Determine who should receive the notification.
@@ -99,31 +53,23 @@ def get_recipients(self, comment):
         Current scheme is as follows:
 
          * For the first comment in a given location, the notification is sent
-         'to' the original author of the thing being commented on, and 'copied'
-         to the authors of any other comments on that thing
+         to any subscribers to that resource
          * For any further comments in a given location, the notification is
-         sent 'to' the author of the last comment in that location, and
-         'copied' to both the original author of the thing and the authors of
-         any other comments on that thing
+         sent to the author of the last comment in that location, and any other
+         subscribers for that resource
         """
         torcpts = set()
+        ccrcpts = set()
 
-        # Get the original author
-        original_author = self._get_original_author(comment)
-
-        # Get other commenters
-        ccrcpts = set(self._get_commenters(comment))
+        for subscription in Subscription.for_comment(self.env, comment,
+                                                     notify=True):
+            torcpts.add(subscription.user)
 
         # Is this a reply, or a new comment?
         thread = self._get_comment_thread(comment)
         if len(thread) > 1:
             # The author of the comment before this one
             torcpts.add(thread[-2].author)
-            # Copy to the original author
-            ccrcpts.add(original_author)
-        else:
-            # This is the first comment in this thread
-            torcpts.add(original_author)
 
         # Should we notify the comment author?
         if not self.notify_self: