Fix a few typos and style in checkdeps

tools/checkdeps/builddeps.py

 #!/usr/bin/env python
 # Copyright 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.
 
 """Traverses the source tree, parses all found DEPS files, and constructs
 a dependency rule table to be used by subclasses.
 
 The format of the deps file:
 
@@ skipping 57 matching lines @@
 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
 directory and then take away permissions from sub-parts, or the reverse.
 
 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 copy
 import os
 import subprocess
-import copy
 
 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
@@ skipping 18 matching lines @@
   def __init__(self,
                base_directory=None,
                verbose=False,
                being_tested=False,
                ignore_temp_rules=False,
                ignore_specific_rules=False):
     """Creates a new DepsBuilder.
 
     Args:
       base_directory: OS-compatible path to root of checkout, e.g. C:\chr\src.
-      verbose: Set to true for debug output.
-      being_tested: Set to true to ignore the DEPS file at tools/checkdeps/DEPS.
+      verbose: Set to True for debug output.
+      being_tested: Set to True to ignore the DEPS file at tools/checkdeps/DEPS.
       ignore_temp_rules: Ignore rules that start with Rule.TEMP_ALLOW ("!").
     """
     base_directory = (base_directory or
                       os.path.join(os.path.dirname(__file__), '..', '..'))
     self.base_directory = os.path.abspath(base_directory)
     self.verbose = verbose
     self._under_test = being_tested
     self._ignore_temp_rules = ignore_temp_rules
     self._ignore_specific_rules = ignore_specific_rules
 
@@ skipping 15 matching lines @@
                          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.deepcopy(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:]
+    norm_base_dir = NormalizePath(os.path.normpath(self.base_directory))
+    if not cur_dir.startswith(norm_base_dir):
+      raise Exception(
+          'Internal error: base directory is not at the beginning for\n'
+          '  %s and base dir\n'
+          '  %s' % (cur_dir, norm_base_dir))
+    relative_dir = os.path.relpath(cur_dir, norm_base_dir)
 
-      source = relative_dir
-      if len(source) == 0:
-        source = 'top level'  # Make the help string a little more meaningful.
-      rules.AddRule('+' + relative_dir,
-                    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))
+    # Make the help string a little more meaningful.
+    source = relative_dir or 'top level'
+    rules.AddRule('+' + relative_dir,
+                  relative_dir,
+                  'Default rule for ' + source)
 
     def ApplyOneRule(rule_str, cur_dir, dependee_regexp=None):
       """Deduces a sensible description for the rule being added, and
       adds the rule with its description to |rules|.
 
       If we are ignoring temporary rules, this function does nothing
       for rules beginning with the Rule.TEMP_ALLOW character.
       """
       if self._ignore_temp_rules and rule_str.startswith(Rule.TEMP_ALLOW):
         return
 
       rule_block_name = 'include_rules'
       if dependee_regexp:
         rule_block_name = 'specific_include_rules'
-      if not relative_dir:
+      if relative_dir:
+        rule_description = relative_dir + "'s %s" % rule_block_name
+      else:
         rule_description = 'the top level %s' % rule_block_name
-      else:
-        rule_description = relative_dir + "'s %s" % rule_block_name
       rules.AddRule(rule_str, relative_dir, rule_description, dependee_regexp)
 
     # Apply the additional explicit rules.
-    for (_, rule_str) in enumerate(includes):
+    for rule_str in includes:
       ApplyOneRule(rule_str, cur_dir)
 
     # Finally, apply the specific rules.
     if not self._ignore_specific_rules:
       for regexp, specific_rules in specific_includes.iteritems():
         for rule_str in specific_rules:
           ApplyOneRule(rule_str, cur_dir, regexp)
 
     return rules
 
@@ skipping 13 matching lines @@
 
     Returns: A tuple containing: (1) the combined set of rules to apply to the
              sub-tree, and (2) a list of all subdirectories that should NOT be
              checked, as specified in the DEPS file (if any).
     """
     norm_dir_name = NormalizePath(dir_name)
 
     # Check for a .svn directory in this directory or check this directory is
     # contained in git source direcotries. This will tell us if it's a source
     # directory and should be checked.
-    if not (os.path.exists(os.path.join(dir_name, ".svn")) or
+    if not (os.path.exists(os.path.join(dir_name, '.svn')) or
             (norm_dir_name in self.git_source_directories)):
-      return (None, [])
+      return None, []
 
     # Check the DEPS file in this directory.
     if self.verbose:
       print 'Applying rules from', dir_name
-    def FromImpl(_unused, _unused2):
+    def FromImpl(*_):
       pass  # NOP function so "From" doesn't fail.
 
-    def FileImpl(_unused):
+    def FileImpl(_):
       pass  # NOP function so "File" doesn't fail.
 
     class _VarImpl:
       def __init__(self, local_scope):
         self._local_scope = local_scope
 
       def Lookup(self, var_name):
         """Implements the Var syntax."""
-        if var_name in self._local_scope.get('vars', {}):
+        try:
           return self._local_scope['vars'][var_name]
-        raise Exception('Var is not defined: %s' % var_name)
+        except KeyError:
+          raise Exception('Var is not defined: %s' % var_name)
 
     local_scope = {}
     global_scope = {
-        'File': FileImpl,
-        'From': FromImpl,
-        'Var': _VarImpl(local_scope).Lookup,
-        }
+      'File': FileImpl,
+      'From': FromImpl,
+      'Var': _VarImpl(local_scope).Lookup,
+    }
     deps_file = os.path.join(dir_name, 'DEPS')
 
     # The second conditional here is to disregard the
     # tools/checkdeps/DEPS file while running tests.  This DEPS file
     # has a skip_child_includes for 'testdata' which is necessary for
     # running production tests, since there are intentional DEPS
     # violations under the testdata directory.  On the other hand when
     # running tests, we absolutely need to verify the contents of that
     # directory to trigger those intended violations and see that they
     # are handled correctly.
     if os.path.isfile(deps_file) and (
-        not self._under_test or not os.path.split(dir_name)[1] == 'checkdeps'):
+        not self._under_test or not os.path.basename(dir_name) == '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, [])
@@ skipping 27 matching lines @@
     """
     norm_dir_path = NormalizePath(dir_path)
 
     if not norm_dir_path.startswith(
         NormalizePath(os.path.normpath(self.base_directory))):
       dir_path = os.path.join(self.base_directory, dir_path)
       norm_dir_path = NormalizePath(dir_path)
 
     parent_dir = os.path.dirname(dir_path)
     parent_rules = None
-    if not norm_dir_path in self.directory_rules:
+    if norm_dir_path not in self.directory_rules:
       parent_rules = self.GetDirectoryRules(parent_dir)
 
     # We need to check for an entry for our dir_path again, in case we
     # are at a path e.g. A/B/C where A/B/DEPS specifies the C
     # subdirectory to be skipped; in this case, the invocation to
     # GetDirectoryRules(parent_dir) has already filled in an entry for
     # A/B/C.
-    if not norm_dir_path in self.directory_rules:
-      if not parent_rules:
+    if norm_dir_path not in self.directory_rules:
+      if parent_rules:
+        self._ApplyDirectoryRulesAndSkipSubdirs(parent_rules, dir_path)
+      else:
         # If the parent directory should be skipped, then the current
         # directory should also be skipped.
         self.directory_rules[norm_dir_path] = None
-      else:
-        self._ApplyDirectoryRulesAndSkipSubdirs(parent_rules, dir_path)
     return self.directory_rules[norm_dir_path]
 
   def _AddGitSourceDirectories(self):
     """Adds any directories containing sources managed by git to
     self.git_source_directories.
     """
     if not os.path.exists(os.path.join(self.base_directory, '.git')):
       return
 
     popen_out = os.popen('cd %s && git ls-files --full-name .' %
                          subprocess.list2cmdline([self.base_directory]))
     for line in popen_out.readlines():
       dir_name = os.path.join(self.base_directory, os.path.dirname(line))
       # Add the directory as well as all the parent directories. Use
       # forward slashes and lower case to normalize paths.
       while dir_name != self.base_directory:
         self.git_source_directories.add(NormalizePath(dir_name))
         dir_name = os.path.dirname(dir_name)
     self.git_source_directories.add(NormalizePath(self.base_directory))