Add custom hooks.

gclient.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.
 
 """Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
                   entries each are maps binding the strings "name" and "url"
                   to strings specifying the name and location of the client
-                  module, as well as "custom_deps" to a map similar to the DEPS
-                  file below.
+                  module, as well as "custom_deps" to a map similar to the deps
+                  section of the DEPS file below, as well as "custom_hooks" to
+                  a list similar to the hooks sections of the DEPS file below.
   .gclient_entries : A cache constructed by 'update' command.  Format is a
                   Python script defining 'entries', a list of the names
                   of all modules in the client
   <module>/DEPS : Python script defining var 'deps' as a map from each requisite
                   submodule name to a URL where it can be found (via one SCM)
 
 Hooks
   .gclient and DEPS files may optionally contain a list named "hooks" to
   allow custom actions to be performed based on files that have changed in the
   working copy as a result of a "sync"/"update" or "revert" operation.  This
   can be prevented by using --nohooks (hooks run by default). Hooks can also
   be forced to run with the "runhooks" operation.  If "sync" is run with
-  --force, all known hooks will run regardless of the state of the working
-  copy.
+  --force, all known but not suppressed hooks will run regardless of the state
+  of the working copy.
 
   Each item in a "hooks" list is a dict, containing these two keys:
     "pattern"  The associated value is a string containing a regular
                expression.  When a file whose pathname matches the expression
                is checked out, updated, or reverted, the hook's "action" will
                run.
     "action"   A list describing a command to run along with its arguments, if
                any.  An action command will run at most one time per gclient
                invocation, regardless of how many files matched the pattern.
                The action is executed in the same directory as the .gclient
                file.  If the first item in the list is the string "python",
                the current Python interpreter (sys.executable) will be used
                to run the command. If the list contains string "$matching_files"
                it will be removed from the list and the list will be extended
                by the list of matching files.
+    "name"     An optional string specifying the group to which a hook belongs
+               for overriding and organizing.
 
   Example:
     hooks = [
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
+      { "pattern": ".",
+        "name": "gyp",
+        "action":  ["python", "src/build/gyp_chromium"]},
     ]
 
 Specifying a target OS
   An optional key named "target_os" may be added to a gclient file to specify
   one or more additional operating systems that should be considered when
   processing the deps_os dict of a DEPS file.
 
   Example:
     target_os = [ "android" ]
 
@@ skipping 93 matching lines @@
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
       raise gclient_utils.Error("Var is not defined: %s" % var_name)
 
 
 class DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
       self, parent, url, safesync_url, managed, custom_deps, custom_vars,
-      deps_file, should_process):
+      custom_hooks, deps_file, should_process):
     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
     self._deps_file = deps_file
     self._url = url
     # 'managed' determines whether or not this dependency is synced/updated by
     # gclient after gclient checks it out initially.  The difference between
     # 'managed' and 'should_process' is that the user specifies 'managed' via
     # the --unmanaged command-line flag or a .gclient config, where
     # 'should_process' is dynamically set by gclient if it goes over its
     # recursion limit and controls gclient's behavior so it does not misbehave.
     self._managed = managed
     self._should_process = should_process
     # This is a mutable value that overrides the normal recursion limit for this
     # dependency.  It is read from the actual DEPS file so cannot be set on
     # class instantiation.
     self.recursion_override = None
     # This is a mutable value which has the list of 'target_os' OSes listed in
     # the current deps file.
     self.local_target_os = None
 
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
     self._custom_deps = custom_deps or {}
+    self._custom_hooks = custom_hooks or []
 
     # TODO(iannucci): Remove this when all masters are correctly substituting
     # the new blink url.
     if (self._custom_vars.get('webkit_trunk', '') ==
         'svn://svn-mirror.golo.chromium.org/webkit-readonly/trunk'):
       new_url = 'svn://svn-mirror.golo.chromium.org/blink/trunk'
       print 'Overwriting Var("webkit_trunk") with %s' % new_url
       self._custom_vars['webkit_trunk'] = new_url
 
     # Post process the url to remove trailing slashes.
@@ skipping 41 matching lines @@
 
   @property
   def custom_vars(self):
     return self._custom_vars.copy()
 
   @property
   def custom_deps(self):
     return self._custom_deps.copy()
 
   @property
+  def custom_hooks(self):
+    return self._custom_hooks[:]
+
+  @property
   def url(self):
     return self._url
 
   @property
   def recursion_limit(self):
     """Returns > 0 if this dependency is not too recursed to be processed."""
     if self.recursion_override is not None:
       return self.recursion_override
     return max(self.parent.recursion_limit - 1, 0)
 
   @property
   def target_os(self):
     if self.local_target_os is not None:
       return tuple(set(self.local_target_os).union(self.parent.target_os))
     else:
       return self.parent.target_os
 
   def get_custom_deps(self, name, url):
     """Returns a custom deps if applicable."""
     if self.parent:
       url = self.parent.get_custom_deps(name, url)
     # None is a valid return value to disable a dependency.
     return self.custom_deps.get(name, url)
 
 
 class Dependency(gclient_utils.WorkItem, DependencySettings):
   """Object that represents a dependency checkout."""
 
   def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
-               custom_vars, deps_file, should_process):
+               custom_vars, custom_hooks, deps_file, should_process):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, safesync_url, managed, custom_deps, custom_vars,
-        deps_file, should_process)
+        custom_hooks, deps_file, should_process)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
 
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
@@ skipping 227 matching lines @@
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
       deps = rel_deps
 
     # Convert the deps into real Dependency.
     deps_to_add = []
     for name, url in deps.iteritems():
       should_process = self.recursion_limit and self.should_process
       deps_to_add.append(Dependency(
-          self, name, url, None, None, None, None,
+          self, name, url, None, None, None, None, None,
           self.deps_file, should_process))
     deps_to_add.sort(key=lambda x: x.name)
-    self.add_dependencies_and_close(deps_to_add, local_scope.get('hooks', []))
+
+    # override named sets of hooks by the custom hooks
+    hooks_to_run = []
+    hook_names_to_suppress = [c.get('name', '') for c in self.custom_hooks]
+    for hook in local_scope.get('hooks', []):
+      if hook.get('name', '') not in hook_names_to_suppress:
+        hooks_to_run.append(hook)
+
+    # add the replacements and any additions
+    for hook in self.custom_hooks:
+      if 'action' in hook:
+        hooks_to_run.append(hook)
+
+    self.add_dependencies_and_close(deps_to_add, hooks_to_run)
     logging.info('ParseDepsFile(%s) done' % self.name)
 
   def add_dependencies_and_close(self, deps_to_add, hooks):
     """Adds the dependencies, hooks and mark the parsing as done."""
     for dep in deps_to_add:
       if dep.verify_validity():
         self.add_dependency(dep)
     self._mark_as_parsed(hooks)
 
   def maybeGetParentRevision(
@@ skipping 369 matching lines @@
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s]
 """)
 
   def __init__(self, root_dir, options):
     # Do not change previous behavior. Only solution level and immediate DEPS
     # are processed.
     self._recursion_limit = 2
-    Dependency.__init__(self, None, None, None, None, True, None, None,
+    Dependency.__init__(self, None, None, None, None, True, None, None, None,
                         'unused', True)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
     else:
       enforced_os = [self.DEPS_OS_CHOICES.get(sys.platform, 'unix')]
     if 'all' in enforced_os:
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
     self._enforced_os = tuple(set(enforced_os))
     self._root_dir = root_dir
@@ skipping 21 matching lines @@
 
     deps_to_add = []
     for s in config_dict.get('solutions', []):
       try:
         deps_to_add.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
             s.get('managed', True),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
+            s.get('custom_hooks', []),
             s.get('deps_file', 'DEPS'),
             True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     self.add_dependencies_and_close(deps_to_add, config_dict.get('hooks', []))
     logging.info('SetConfig() done')
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir,
@@ skipping 831 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: