owners.py: partial fix for owners-check perf regression

owners.py

 # Copyright (c) 2012 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.
 
 """A database of OWNERS files.
 
 OWNERS files indicate who is allowed to approve changes in a specific directory
 (or who is allowed to make changes without needing approval of another OWNER).
 Note that all changes must still be reviewed by someone familiar with the code,
 so you may need approval from both an OWNER and a reviewer in many cases.
@@ skipping 100 matching lines @@
 
     # Mapping of owners to the paths or globs they own.
     self._owners_to_paths = {EVERYONE: set()}
 
     # Mapping of paths to authorized owners.
     self._paths_to_owners = {}
 
     # Mapping reviewers to the preceding comment per file in the OWNERS files.
     self.comments = {}
 
+    # Cache of compiled regexes for _fnmatch()
+    self._fnmatch_cache = {}
+
     # Set of paths that stop us from looking above them for owners.
     # (This is implicitly true for the root directory).
     self._stop_looking = set([''])
 
     # Set of files which have already been read.
     self.read_files = set()
 
   def reviewers_for(self, files, author):
     """Returns a suggested set of reviewers that will cover the files.
 
@@ skipping 59 matching lines @@
   def load_data_needed_for(self, files):
     for f in files:
       dirpath = self.os_path.dirname(f)
       while not self._owners_for(dirpath):
         self._read_owners(self.os_path.join(dirpath, 'OWNERS'))
         if self._should_stop_looking(dirpath):
           break
         dirpath = self.os_path.dirname(dirpath)
 
   def _should_stop_looking(self, objname):
-    return any(fnmatch.fnmatch(objname, stop_looking)
+    return any(self._fnmatch(objname, stop_looking)
                for stop_looking in self._stop_looking)
 
   def _owners_for(self, objname):
     obj_owners = set()
     for owned_path, path_owners in self._paths_to_owners.iteritems():
-      if fnmatch.fnmatch(objname, owned_path):
+      if self._fnmatch(objname, owned_path):
         obj_owners |= path_owners
     return obj_owners
 
   def _read_owners(self, path):
     owners_path = self.os_path.join(self.root, path)
     if not self.os_path.exists(owners_path):
       return
 
     if owners_path in self.read_files:
       return
@@ skipping 115 matching lines @@
           # If the same person is in multiple OWNERS files above a given
           # directory, only count the closest one.
           if not any(current_dir == el[0] for el in all_possible_owners[owner]):
             all_possible_owners[owner].append((current_dir, distance))
         if self._should_stop_looking(dirname):
           break
         dirname = self.os_path.dirname(dirname)
         distance += 1
     return all_possible_owners
 
+  def _fnmatch(self, filename, pattern):
+    """Same as fnmatch.fnmatch(), but interally caches the compiled regexes."""
+    matcher = self._fnmatch_cache.get(pattern)
+    if matcher is None:
+      matcher = re.compile(fnmatch.translate(pattern)).match
+      self._fnmatch_cache[pattern] = matcher
+    return matcher(filename)
+
   @staticmethod
   def total_costs_by_owner(all_possible_owners, dirs):
     # We want to minimize both the number of reviewers and the distance
     # from the files/dirs needing reviews. The "pow(X, 1.75)" below is
     # an arbitrarily-selected scaling factor that seems to work well - it
     # will select one reviewer in the parent directory over three reviewers
     # in subdirs, but not one reviewer over just two.
     result = {}
     for owner in all_possible_owners:
       total_distance = 0
@@ skipping 10 matching lines @@
   @staticmethod
   def lowest_cost_owner(all_possible_owners, dirs):
     total_costs_by_owner = Database.total_costs_by_owner(all_possible_owners,
                                                          dirs)
     # Return the lowest cost owner. In the case of a tie, pick one randomly.
     lowest_cost = min(total_costs_by_owner.itervalues())
     lowest_cost_owners = filter(
         lambda owner: total_costs_by_owner[owner] == lowest_cost,
         total_costs_by_owner)
     return random.Random().choice(lowest_cost_owners)