First pass at Swarm interface integration for inline comments

inlineplz/interfaces/__init__.py

@@ -4,7 +4,9 @@
 from __future__ import unicode_literals
 
 from inlineplz.interfaces.github import GitHubInterface
+from inlineplz.interfaces.swarm import SwarmInterface
 
 INTERFACES = {
-    'github': GitHubInterface
+    'github': GitHubInterface,
+    'swarm': SwarmInterface
 }

inlineplz/interfaces/github.py

@@ -15,7 +15,7 @@
 
 
 class GitHubInterface(InterfaceBase):
-    def __init__(self, owner, repo, pr=None, branch=None, token=None, url=None):
+    def __init__(self, args):
         """
         GitHubInterface lets us post messages to GitHub.
 
@@ -28,6 +28,31 @@ def __init__(self, owner, repo, pr=None, branch=None, token=None, url=None):
 
         url is the base URL of your GitHub instance, such as https://github.com
         """
+        url = args.url
+        if args.repo_slug:
+            owner = args.repo_slug.split('/')[0]
+            repo = args.repo_slug.split('/')[1]
+        else:
+            owner = args.owner
+            repo = args.repo
+        if args.url:
+            try:
+                url_to_parse = args.url
+                # giturlparse won't parse URLs that don't end in .git
+                if not url_to_parse.endswith('.git'):
+                    url_to_parse += '.git'
+                parsed = giturlparse.parse(url_to_parse)
+                url = parsed.resource
+                if not url.startswith('https://'):
+                    url = 'https://' + url
+                owner = parsed.owner
+                repo = parsed.name
+            except giturlparse.parser.ParserError:
+                pass
+
+        pr = args.pull_request
+        token = args.token
+
         self.github = None
         if not url or url == 'https://github.com':
             self.github = github3.GitHub(token=token)
@@ -89,35 +114,36 @@ def post_messages(self, messages, max_comments):
                 return messages_to_post
             if not msg.comments:
                 continue
-            msg_position = self.position(msg)
+            msg_path = os.path.relpath(msg.path).replace('\\', '/').strip()
+            msg_position = self.position(msg, msg_path)
             if msg_position:
                 messages_to_post += 1
-                if not self.is_duplicate(msg, msg_position):
+                if not self.is_duplicate(msg, msg_path, msg_position):
                     # skip this message if we already have too many comments on this file
                     # max comments / 5 is an arbitrary number i totally made up. should maybe be configurable.
-                    if paths.setdefault(msg.path, 0) > max_comments // 5:
+                    if paths.setdefault(msg_path, 0) > max_comments // 5:
                         continue
                     try:
                         print('Creating review comment: {0}'.format(msg))
                         self.pull_request.create_review_comment(
                             self.format_message(msg),
                             self.last_sha,
-                            msg.path,
+                            msg_path,
                             msg_position
                         )
                     except github3.GitHubError:
                         pass
-                    paths[msg.path] += 1
+                    paths[msg_path] += 1
                     messages_posted += 1
                     if max_comments >= 0 and messages_posted > max_comments:
                         break
         print('{} messages posted to Github.'.format(messages_to_post))
         return messages_to_post
 
-    def is_duplicate(self, message, position):
+    def is_duplicate(self, message, path, position):
         for comment in self.pull_request.review_comments():
             if (comment.position == position and
-                    comment.path == message.path and
+                    comment.path == path and
                     comment.body.strip() == self.format_message(message).strip()):
                 return True
         return False
@@ -134,14 +160,14 @@ def format_message(message):
             )
         return '`{0}`'.format(list(message.comments)[0].strip())
 
-    def position(self, message):
+    def position(self, message, path):
         """Calculate position within the PR, which is not the line number"""
         if not message.line_number:
             message.line_number = 1
         patch = unidiff.PatchSet(self.diff.split('\n'))
         for patched_file in patch:
             target = patched_file.target_file.lstrip('b/')
-            if target == message.path:
+            if target == path:
                 offset = 1
                 for hunk_no, hunk in enumerate(patched_file):
                     for position, hunk_line in enumerate(hunk):

inlineplz/interfaces/swarm.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+import requests
+import random
+import subprocess
+
+from inlineplz.interfaces.base import InterfaceBase
+
+class SwarmInterface(InterfaceBase):
+    def __init__(self, args):
+        """
+        SwarmInterface lets us post messages to Swarm (Helix).
+
+        username and password are the credentials used to access Swarm/Perforce.
+        host is the server (And any additional paths before the api)
+        topic is the the review you are commenting on (for reviews, it will typically be "review/###" for some review number)
+        """
+        self.username = args.username
+        self.password = args.password
+        self.host = args.host
+        self.topic = args.topic
+        self.version = 'v8'
+
+    def post_messages(self, messages, max_comments):
+        # randomize message order to more evenly distribute messages across different files
+        messages = list(messages)
+        random.shuffle(messages)
+
+        messages_to_post = 0
+        messages_posted = 0
+        current_comments = self.get_comments(max_comments)
+        for msg in messages:
+            if not msg.comments:
+                continue
+            messages_to_post += 1
+            body = self.format_message(msg)
+            proc = subprocess.Popen(["p4", "fstat", "-T", "depotFile", msg.path], stdout=subprocess.PIPE)
+            output = proc.stdout.read()
+            l = output.split()
+            if (len(l) != 3):
+                print("Can't find depotFile for '{}': {}".format(msg.path, output))
+                continue
+            path = output.split()[2]
+            if self.is_duplicate(current_comments, body, path, msg.line_number):
+                print("Duplicate for {}:{}".format(path, msg.line_number))
+                continue
+            # try to send swarm post comment
+            self.post_comment(body, path, msg.line_number)
+            messages_posted += 1
+            if max_comments >= 0 and messages_posted > max_comments:
+                break
+        print('{} messages posted to Swarm.'.format(messages_to_post))
+        return messages_to_post
+
+    def post_comment(self, body, path, line_number):
+        # https://www.perforce.com/perforce/doc.current/manuals/swarm/index.html#Swarm/swarm-apidoc.html#Comments___Swarm_Comments%3FTocPath%3DSwarm%2520API%7CAPI%2520Endpoints%7C_____3
+        url = "https://{}/api/{}/comments".format(self.host, self.version)
+        payload = {
+            'topic': self.topic,
+            'body': body,
+            'context[file]': path,
+            'context[rightLine]': line_number
+        }
+        print("".format(payload))
+        r = requests.post(url, auth=(self.username, self.password), data=payload)
+
+    def get_comments(self, max_comments=100):
+        # https://www.perforce.com/perforce/doc.current/manuals/swarm/index.html#Swarm/swarm-apidoc.html#Comments___Swarm_Comments%3FTocPath%3DSwarm%2520API%7CAPI%2520Endpoints%7C_____3
+        parameters = "topic={}&max={}".format(self.topic, max_comments)
+        url = "https://{}/api/{}/comments?{}".format(self.host, self.version, parameters)
+        response = requests.get(url, auth=(self.username, self.password))
+        if (response.status_code != requests.codes.ok):
+            print("Can't get comments, status code: {}".format(response.status_code))
+            return {}
+        return response.json()["comments"]
+
+    @staticmethod
+    def is_duplicate(comments, body, path, line_number):
+        for comment in comments:
+            try:
+                if (comment["context"]["rightLine"] == line_number and
+                    comment["context"]["file"] == path and
+                    comment["body"].strip() == body.strip()):
+                    print("Dupe: {}:{}".format(comment["context"]["file"], comment["context"]["rightLine"]))
+                    return True
+            except (KeyError, TypeError) as exceptError:
+                continue
+        return False
+
+    @staticmethod
+    def format_message(message):
+        if not message.comments:
+            return ''
+        return (
+            '```\n' +
+            '\n'.join(sorted(list(message.comments))) +
+            '\n```'
+        )

inlineplz/main.py

@@ -28,7 +28,11 @@ def main():
     parser.add_argument('--branch', type=str)
     parser.add_argument('--token', type=str)
     parser.add_argument('--interface', type=str, choices=interfaces.INTERFACES)
-    parser.add_argument('--url', type=str)
+    parser.add_argument('--url', type=str, default=None)
+    parser.add_argument('--username', type=str)
+    parser.add_argument('--password', type=str)
+    parser.add_argument('--host', type=str)
+    parser.add_argument('--topic', type=str)
     parser.add_argument('--enabled-linters', type=str, nargs='+')
     parser.add_argument('--disabled-linters', type=str, nargs='+')
     parser.add_argument('--dryrun', action='store_true')
@@ -120,28 +124,6 @@ def inline(args):
     trusted = args.trusted
     args = load_config(args)
 
-    # TODO: consider moving this git parsing stuff into the github interface
-    url = args.url
-    if args.repo_slug:
-        owner = args.repo_slug.split('/')[0]
-        repo = args.repo_slug.split('/')[1]
-    else:
-        owner = args.owner
-        repo = args.repo
-    if args.url:
-        try:
-            url_to_parse = args.url
-            # giturlparse won't parse URLs that don't end in .git
-            if not url_to_parse.endswith('.git'):
-                url_to_parse += '.git'
-            parsed = giturlparse.parse(url_to_parse)
-            url = parsed.resource
-            if not url.startswith('https://'):
-                url = 'https://' + url
-            owner = parsed.owner
-            repo = parsed.name
-        except giturlparse.parser.ParserError:
-            pass
     if not args.dryrun and args.interface not in interfaces.INTERFACES:
         print('Valid inline-plz config not found')
         return 1
@@ -163,14 +145,7 @@ def inline(args):
         print_messages(messages)
         return 0
     try:
-        my_interface = interfaces.INTERFACES[args.interface](
-            owner,
-            repo,
-            args.pull_request,
-            args.branch,
-            args.token,
-            url
-        )
+        my_interface = interfaces.INTERFACES[args.interface](args)
         if my_interface.post_messages(messages, args.max_comments) and not args.zero_exit:
             return 1
     except KeyError:

inlineplz/message.py

@@ -15,7 +15,7 @@ def __init__(self):
         self.messages = {}
 
     def add_message(self, path, line, message):
-        path = os.path.relpath(path).replace('\\', '/').strip()
+        path = path.replace('\\', '/').strip()
         # replace backticks with single quotes to avoid markdown escaping issues
         message = message.replace('`', '\'').strip()
         try:
@@ -42,7 +42,7 @@ def get_messages(self):
 class Message(object):
 
     def __init__(self, path, line_number):
-        self.path = os.path.relpath(path).replace('\\', '/')
+        self.path = path.replace('\\', '/').strip()
         self.line_number = int(line_number)
         self.comments = set()
 

setup.py

@@ -19,7 +19,8 @@
     'uritemplate.py',
     'dirtyjson',
     'python-dateutil',
-    'git-url-parse'
+    'git-url-parse',
+    'requests'
 ]
 
 test_requirements = [