Fix the dependency checker tool. Rules for a directory did modify their direc...

tools/checkdeps/checkdeps.py

 #!/usr/bin/python
 # Copyright (c) 2006-2008 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.
 
 """Makes sure that files include headers from allowed directories.
 
 Checks DEPS files in the source tree for rules, and applies those rules to
 "#include" commands in source files. Any source file including something not
 permitted by the DEPS files will fail.
@@ skipping 38 matching lines @@
 
 Note that all directory separators must be slashes (Unix-style) and not
 backslashes. All directories should be relative to the source root and use
 only lowercase.
 """
 
 import os
 import optparse
 import re
 import sys
+import copy
 
 # Variable name used in the DEPS file to specify module-level deps.
 DEPS_VAR_NAME = "deps"
 
 # Variable name used in the DEPS file to add or subtract include files from
 # the module-level deps.
 INCLUDE_RULES_VAR_NAME = "include_rules"
 
 # Optionally present in the DEPS file to list subdirectories which should not
 # be checked. This allows us to skip third party code, for example.
@@ skipping 104 matching lines @@
   Args:
     existing_rules: A set of existing rules that will be combined.
     deps: The list of imports from the "deps" section of the DEPS file.
     include: The list of rules from the "include_rules" section of DEPS.
     cur_dir: The current directory. We will create an implicit rule that
              allows inclusion from this directory.
 
   Returns: A new set of rules combining the existing_rules with the other
            arguments.
   """
-  rules = existing_rules
+  rules = copy.copy(existing_rules)
 
   # First apply the implicit "allow" rule for the current directory.
   if cur_dir.lower().startswith(BASE_DIRECTORY):
     relative_dir = cur_dir[len(BASE_DIRECTORY) + 1:]
     # Normalize path separators to slashes.
     relative_dir = relative_dir.replace("\\", "/")
     source = relative_dir
     if len(source) == 0:
       source = "top level"  # Make the help string a little more meaningful.
     rules.AddRule("+" + relative_dir, "Default rule for " + source)
@@ skipping 54 matching lines @@
 
     def Lookup(self, var_name):
       """Implements the Var syntax."""
       if var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
       raise Error("Var is not defined: %s" % var_name)
 
   local_scope = {}
   global_scope = {"From": FromImpl, "Var": _VarImpl(local_scope).Lookup}
   deps_file = os.path.join(dir_name, "DEPS")
-  if not os.path.exists(deps_file):
-    if VERBOSE:
-      print "  No deps file found in", dir_name
-    return (existing_rules, [])  # Nothing to change from the input rules.
 
-  execfile(deps_file, global_scope, local_scope)
+  if os.path.exists(deps_file):
+    execfile(deps_file, global_scope, local_scope)
+  elif VERBOSE:
+    print "  No deps file found in", dir_name
 
+  # Even if a DEPS file does not exist we still invoke ApplyRules
+  # to apply the implicit "allow" rule for the current directory
   deps = local_scope.get(DEPS_VAR_NAME, {})
   include_rules = local_scope.get(INCLUDE_RULES_VAR_NAME, [])
   skip_subdirs = local_scope.get(SKIP_SUBDIRS_VAR_NAME, [])
 
   return (ApplyRules(existing_rules, deps, include_rules, dir_name),
           skip_subdirs)
 
 
 def ShouldCheckFile(file_name):
   """Returns True if the given file is a type we want to check."""
@@ skipping 66 matching lines @@
     if VERBOSE:
       print "Unable to open file: " + file_name
     cur_file.close()
 
   # Map empty string to None for easier checking.
   if len(ret_val) == 0:
     return None
   return ret_val
 
 
-def CheckDirectory(rules, dir_name):
-  (rules, skip_subdirs) = ApplyDirectoryRules(rules, dir_name)
+def CheckDirectory(parent_rules, dir_name):
+  (rules, skip_subdirs) = ApplyDirectoryRules(parent_rules, dir_name)
   if rules == None:
     return True
 
   # Collect a list of all files and directories to check.
   files_to_check = []
   dirs_to_check = []
   success = True
   contents = os.listdir(dir_name)
   for cur in contents:
     if cur in skip_subdirs:
@@ skipping 83 matching lines @@
   option_parser.add_option("", "--root", default="", dest="base_directory",
                            help='Specifies the repository root. This defaults '
                            'to "../../.." relative to the script file, which '
                            'will normally be the repository root.')
   option_parser.add_option("-v", "--verbose", action="store_true",
                            default=False, help="Print debug logging")
   options, args = option_parser.parse_args()
   main(options, args)