Implement mail dispatcher app.

reviewbot/handlers/policy_checklist/parser.py

+# Copyright (c) 2013 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import re
+
+import util
+
+
+CONTEXT_THRESHOLD = 12
+PROPERTY_NAME_RE = re.compile(r"^\s*'(\w+)'\s*:")
+
+
+def nmin(*args):
+  """Calculates the minimum of |args|, ignoring None entries."""
+  values = [v for v in args if v is not None]
+  return None if len(values) == 0 else min(values)
+
+
+def nmax(*args):
+  """Calculates the maximum of |args|, ignoring None entries."""
+  values = [v for v in args if v is not None]
+  return None if len(values) == 0 else max(values)
+
+
+def nadd(a, b):
+  """Calculates a + b, returning None if either a or b is None"""
+  return None if (a is None or b is None) else a + b
+
+
+def nsub(a, b):
+  """Calculates a - b, returning None if either a or b is None"""
+  return None if (a is None or b is None) else a - b
+
+
+def get_indentation_level(line):
+  """Returns the indentation level (number of leading spaces) for |line|."""
+  nspaces = len(line) - len(line.lstrip(' '))
+  return None if nspaces == 0 else nspaces
+
+
+class PolicyChangeParser(object):
+  """Parses a policy_templates.json diff to identify logical changes.
+
+  This takes a list of triples of the form (old_line, new_line, text) as
+  returned by patching.ParsePatchToLines and produces a list of dictionaries
+  describing the logical changes that have been made. The dictionaries contain
+  these keys:
+    * start: A pair (old_line, new_line) indicating where the change starts.
+    * end: A pair (old_line, new_line) indicating where the change ends.
+    * comment_pos: A pair (old_line, new_line), indicating a suitable place to
+                   put an inline comment. This is typically the line where the
+                   policy name is found in the diff.
+    * additions: Whether there have been line additions.
+    * removals: Whether there have been line removals.
+  """
+
+  def __init__(self, lines):
+    self.lines = lines
+    self.chunks_list = []
+    self.reset()
+
+  def run(self):
+    """Main parsing function.
+
+    The code goes over the diff line by line, keeping track of the current line.
+    It keeps track of the current line numbers, and where the last changes
+    happened in the old and new version of the file.
+
+    Certain events trigger start of a new logical change. These are
+    discontinuities in the cursor position and decreases of the indentation
+    level. Once a block closes, the information for that block is recorded in
+    the result list.
+    """
+    self.chunks_list = []
+    self.last_change = [None, None]
+    cursor = [None, None]
+    self.reset()
+    for (a_line, b_line, line) in self.lines:
+      # Skip comment lines.
+      if line.startswith('#'):
+        continue
+
+      # See whether the current line has a JSON property.
+      keyword = None
+      match = PROPERTY_NAME_RE.match(line)
+      if match:
+        keyword = match.group(1).lower()
+
+
+      # Check whether the current block closes.
+      line_indent = get_indentation_level(line)
+      if (self.block_indent is not None and
+            line_indent is not None and
+            line_indent < self.block_indent):
+        self.block_closed = True
+
+      # Update various cursors.
+      cursor = [nmax(a_line, cursor[0]), nmax(b_line, cursor[1])]
+      offset = nmin(nsub(cursor[0], self.last_change[0]),
+                    nsub(cursor[1], self.last_change[1]))
+
+      # Update change tracking state.
+      if a_line is not None and b_line is None:
+        self.removals = True
+        self.last_change[0] = a_line
+        self.text_changed |= any([c.isalnum() for c in line])
+      elif a_line is None and b_line is not None:
+        self.additions = True
+        self.last_change[1] = b_line
+        self.text_changed |= any([c.isalnum() for c in line])
+
+      # If the indentation block closes or the last chunk is too far away,
+      # assume a new one starts.
+      if (self.block_closed or
+          (offset is not None and (offset > CONTEXT_THRESHOLD))):
+        self.flush_chunk()
+
+      # Try to figure out block indent from properties exclusively used for
+      # policy definitions.
+      if (self.block_indent is None and
+          keyword in ('id', 'schema', 'future', 'features', 'supported_on',
+                      'example_value', 'deprecated')):
+        self.block_indent = line_indent
+
+      # Put the comment on the policy name property if we see it fly by.
+      if keyword == 'name':
+        # Filter out name labels on enum items and schemas.
+        if self.block_indent is not None and self.block_indent != line_indent:
+          pass
+        elif a_line is not None and b_line is None:
+          self.comment_pos[0] = a_line
+        elif a_line is None and b_line is not None:
+          self.comment_pos[1] = b_line
+
+      self.chunk_start = [nmin(self.last_change[0], self.chunk_start[0]),
+                          nmin(self.last_change[1], self.chunk_start[1])]
+
+    # Flush the last chunk.
+    if self.chunk_start != [None, None]:
+      self.flush_chunk()
+
+  def flush_chunk(self):
+    if self.text_changed:
+      comment_pos = [nmax(self.chunk_start[0], self.comment_pos[0]),
+                     nmax(self.chunk_start[1], self.comment_pos[1])]
+      self.chunks_list.append(
+          util.ObjectDict(
+              { 'start': self.chunk_start,
+                'end': [nadd(self.last_change[0], 1),
+                        nadd(self.last_change[1], 1)],
+                'comment_pos': comment_pos,
+                'additions': self.additions,
+                'removals': self.removals }))
+    self.reset()
+
+  def reset(self):
+    # This is called from __init__.
+    # pylint: disable=W0201
+    self.chunk_start = [None, None]
+    self.last_change = [None, None]
+    self.comment_pos = [None, None]
+    self.block_indent = None
+    self.block_closed = False
+    self.additions = False
+    self.removals = False
+    self.text_changed = False
+
+
+def parse(lines):
+  """Helper function to parse lines to a list of chunks directly."""
+  parser = PolicyChangeParser(lines)
+  parser.run()
+  return parser.chunks_list