Add ability to write include rules specific to subsets of files in a directory.

tools/checkdeps/checkdeps.py

 #!/usr/bin/env python
 # 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.
 
 """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 29 matching lines @@
 
     # And it can include files from this other directory even though there is
     # no deps rule for it.
     "+tools/crime_fighter",
 
     # This dependency is allowed for now but work is ongoing to remove it,
     # so you shouldn't add further dependencies on it.
     "!base/evil/ok_for_now.h",
   }
 
+If you have certain include rules that should only be applied for some
+files within this directory and subdirectories, you can write a
+section named specific_include_rules that is a hash map of regular
+expressions to the list of rules that should apply to files matching
+them.  Note that such rules will always be applied before the rules
+from 'include_rules' have been applied, but the order in which rules
+associated with different regular expressions is applied is arbitrary.
+
+  specific_include_rules = {
+    ".*_(unit|browser|api)test\.cc": [
+      "+libraries/testsupport",
+    ],
+  }
+
 DEPS files may be placed anywhere in the tree. Each one applies to all
 subdirectories, where there may be more DEPS files that provide additions or
 subtractions for their own sub-trees.
 
 There is an implicit rule for the current directory (where the DEPS file lives)
 and all of its subdirectories. This prevents you from having to explicitly
 allow the current directory everywhere.  This implicit rule is applied first,
 so you can modify or remove it using the normal include rules.
 
 The rules are processed in order. This means you can explicitly allow a higher
@@ skipping 13 matching lines @@
 import cpp_checker
 import java_checker
 from results import NormalResultsFormatter, TemporaryRulesFormatter
 from rules import Rule, Rules
 
 
 # Variable name used in the DEPS file to add or subtract include files from
 # the module-level deps.
 INCLUDE_RULES_VAR_NAME = 'include_rules'
 
+# Variable name used in the DEPS file to add or subtract include files
+# from module-level deps specific to files whose basename (last
+# component of path) matches a given regular expression.
+SPECIFIC_INCLUDE_RULES_VAR_NAME = 'specific_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.
 SKIP_SUBDIRS_VAR_NAME = 'skip_child_includes'
 
 
 def NormalizePath(path):
   """Returns a path normalized to how we write DEPS rules and compare paths.
   """
   return path.lower().replace('\\', '/')
 
@@ skipping 30 matching lines @@
     self._ApplyDirectoryRulesAndSkipSubdirs(Rules(), self.base_directory)
 
   def Report(self):
     """Prints a report of results, and returns an exit code for the process."""
     if self.results_formatter.GetResults():
       self.results_formatter.PrintResults()
       return 1
     print '\nSUCCESS\n'
     return 0
 
-  def _ApplyRules(self, existing_rules, includes, cur_dir):
+  def _ApplyRules(self, existing_rules, includes, specific_includes, cur_dir):
     """Applies the given include rules, returning the new rules.
 
     Args:
       existing_rules: A set of existing rules that will be combined.
       include: The list of rules from the "include_rules" section of DEPS.
+      specific_includes: E.g. {'.*_unittest\.cc': ['+foo', '-blat']} rules
+                         from the "specific_include_rules" section of DEPS.
       cur_dir: The current directory, normalized path. 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 = copy.copy(existing_rules)
 
     # First apply the implicit "allow" rule for the current directory.
     if cur_dir.startswith(
           NormalizePath(os.path.normpath(self.base_directory))):
       relative_dir = cur_dir[len(self.base_directory) + 1:]
 
       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)
     else:
       raise Exception('Internal error: base directory is not at the beginning' +
                       ' for\n  %s and base dir\n  %s' %
                       (cur_dir, self.base_directory))
 
-    # Last, apply the additional explicit rules.
+    def AddRuleWithDescription(rule_str, dependee_regexp=None):
+      rule_block_name = 'include_rules'
+      if dependee_regexp:
+        rule_block_name = 'specific_include_rules'
+      if not relative_dir:
+        rule_description = 'the top level %s' % rule_block_name
+      else:
+        rule_description = relative_dir + "'s %s" % rule_block_name
+      rules.AddRule(rule_str, rule_description, dependee_regexp)
+
+    # Apply the additional explicit rules.
     for (_, rule_str) in enumerate(includes):
-      if not relative_dir:
-        rule_description = 'the top level include_rules'
-      else:
-        rule_description = relative_dir + "'s include_rules"
-      rules.AddRule(rule_str, rule_description)
+      AddRuleWithDescription(rule_str)
+
+    # Finally, apply the specific rules.
+    for regexp, specific_rules in specific_includes.iteritems():
+      for rule_str in specific_rules:
+        AddRuleWithDescription(rule_str, regexp)
 
     return rules
 
   def _ApplyDirectoryRules(self, existing_rules, dir_name):
     """Combines rules from the existing rules and the new directory.
 
     Any directory can contain a DEPS file. Toplevel DEPS files can contain
     module dependencies which are used by gclient. We use these, along with
     additional include rules and implicit rules for the given directory, to
     come up with a combined set of rules to apply for the directory.
@@ skipping 54 matching lines @@
     # are handled correctly.
     if os.path.isfile(deps_file) and (
         not self._under_test or not os.path.split(dir_name)[1] == 'checkdeps'):
       execfile(deps_file, global_scope, local_scope)
     elif self.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
     include_rules = local_scope.get(INCLUDE_RULES_VAR_NAME, [])
+    specific_include_rules = local_scope.get(SPECIFIC_INCLUDE_RULES_VAR_NAME,
+                                             {})
     skip_subdirs = local_scope.get(SKIP_SUBDIRS_VAR_NAME, [])
 
-    return (self._ApplyRules(existing_rules, include_rules, norm_dir_name),
+    return (self._ApplyRules(existing_rules, include_rules,
+                             specific_include_rules, norm_dir_name),
             skip_subdirs)
 
   def _ApplyDirectoryRulesAndSkipSubdirs(self, parent_rules, dir_path):
     """Given |parent_rules| and a subdirectory |dir_path| from the
     directory that owns the |parent_rules|, add |dir_path|'s rules to
     |self.directory_rules|, and add None entries for any of its
     subdirectories that should be skipped.
     """
     directory_rules, excluded_subdirs = self._ApplyDirectoryRules(parent_rules,
                                                                   dir_path)
@@ skipping 95 matching lines @@
     """
     cpp = cpp_checker.CppChecker(self.verbose)
     problems = []
     for file_path, include_lines in added_includes:
       # TODO(joi): Make this cover Java as well.
       if not cpp.IsCppFile(file_path):
         pass
       rules_for_file = self.GetDirectoryRules(os.path.dirname(file_path))
       if rules_for_file:
         for line in include_lines:
-          is_include, violation = cpp.CheckLine(rules_for_file, line, True)
+          is_include, violation = cpp.CheckLine(
+              rules_for_file, line, file_path, True)
           if violation:
             rule_type = violation.violated_rule.allow
             if rule_type != Rule.ALLOW:
               violation_text = NormalResultsFormatter.FormatViolation(
                   violation, self.verbose)
               problems.append((file_path, rule_type, violation_text))
     return problems
 
   def _AddGitSourceDirectories(self):
     """Adds any directories containing sources managed by git to
@@ skipping 60 matching lines @@
   print 'Checking:', start_dir
 
   if options.temprules:
     deps_checker.results_formatter = TemporaryRulesFormatter()
   deps_checker.CheckDirectory(start_dir)
   return deps_checker.Report()
 
 
 if '__main__' == __name__:
   sys.exit(main())