return a list of uncovered files, not uncovered dirs

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 111 matching lines @@
     self._check_paths(files)
     self._load_data_needed_for(files)
     suggested_owners = self._covering_set_of_owners_for(files)
     if EVERYONE in suggested_owners:
       if len(suggested_owners) > 1:
         suggested_owners.remove(EVERYONE)
       else:
         suggested_owners = set(['<anyone>'])
     return suggested_owners
 
-  # TODO(dpranke): rename to objects_not_covered_by
-  def directories_not_covered_by(self, files, reviewers):
-    """Returns the set of directories that are not owned by a reviewer.
-
-    Determines which of the given files are not owned by at least one of the
-    reviewers, then returns a set containing the applicable enclosing
-    directories, i.e. the ones upward from the files that have OWNERS files.
+  def files_not_covered_by(self, files, reviewers):
+    """Returns the files not owned by one of the reviewers.
 
     Args:
         files is a sequence of paths relative to (and under) self.root.
         reviewers is a sequence of strings matching self.email_regexp.
     """
     self._check_paths(files)
     self._check_reviewers(reviewers)
     self._load_data_needed_for(files)
 
-    objs = set()
-    for f in files:
-      if f in self.owners_for:
-        objs.add(f)
-      else:
-        objs.add(self.os_path.dirname(f))
+    covered_objs = self._objs_covered_by(reviewers)
+    uncovered_files = [f for f in files
+                       if not self._is_obj_covered_by(f, covered_objs)]
 
-    covered_objs = self._objs_covered_by(reviewers)
-    uncovered_objs = [self._enclosing_obj_with_owners(o) for o in objs
-                      if not self._is_obj_covered_by(o, covered_objs)]
-
-    return set(uncovered_objs)
-
-  objects_not_covered_by = directories_not_covered_by
+    return set(uncovered_files)
 
   def _check_paths(self, files):
     def _is_under(f, pfx):
       return self.os_path.abspath(self.os_path.join(pfx, f)).startswith(pfx)
     _assert_is_collection(files)
     assert all(not self.os_path.isabs(f) and
                 _is_under(f, self.os_path.abspath(self.root)) for f in files)
 
   def _check_reviewers(self, reviewers):
     _assert_is_collection(reviewers)
     assert all(self.email_regexp.match(r) for r in reviewers)
 
-  # TODO(dpranke): Rename to _objs_covered_by and update_callers
-  def _dirs_covered_by(self, reviewers):
-    dirs = self.owned_by[EVERYONE]
+  def _objs_covered_by(self, reviewers):
+    objs = self.owned_by[EVERYONE]
     for r in reviewers:
-      dirs = dirs | self.owned_by.get(r, set())
-    return dirs
+      objs = objs | self.owned_by.get(r, set())
+    return objs
 
-  _objs_covered_by = _dirs_covered_by
+  def _stop_looking(self, objname):
+    return objname in self.stop_looking
 
-  def _stop_looking(self, dirname):
-    return dirname in self.stop_looking
+  def _is_obj_covered_by(self, objname, covered_objs):
+    while not objname in covered_objs and not self._stop_looking(objname):
+      objname = self.os_path.dirname(objname)
+    return objname in covered_objs
 
-  # TODO(dpranke): Rename to _is_dir_covered_by and update callers.
-  def _is_dir_covered_by(self, dirname, covered_dirs):
-    while not dirname in covered_dirs and not self._stop_looking(dirname):
-      dirname = self.os_path.dirname(dirname)
-    return dirname in covered_dirs
-
-  _is_obj_covered_by = _is_dir_covered_by
-
-  # TODO(dpranke): Rename to _enclosing_obj_with_owners and update callers.
-  def _enclosing_dir_with_owners(self, directory):
+  def _enclosing_dir_with_owners(self, objname):
     """Returns the innermost enclosing directory that has an OWNERS file."""
-    dirpath = directory
+    dirpath = objname
     while not dirpath in self.owners_for:
       if self._stop_looking(dirpath):
         break
       dirpath = self.os_path.dirname(dirpath)
     return dirpath
 
-  _enclosing_obj_with_owners = _enclosing_dir_with_owners
-
   def _load_data_needed_for(self, files):
     for f in files:
       dirpath = self.os_path.dirname(f)
       while not dirpath in self.owners_for:
         self._read_owners_in_dir(dirpath)
         if self._stop_looking(dirpath):
           break
         dirpath = self.os_path.dirname(dirpath)
 
   def _read_owners_in_dir(self, dirpath):
@@ skipping 93 matching lines @@
         if num_directories_owned:
           total_costs_by_owner[owner] = (total_distance /
                                          pow(num_directories_owned, 1.75))
 
     # 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)