Add the ability to generate a depfile when running grit build.

grit/tool/build.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.
 
 '''The 'grit build' tool along with integration for this tool with the
 SCons build system.
 '''
 
 import filecmp
@@ skipping 80 matching lines @@
 '''
 
   def ShortDescription(self):
     return 'A tool that builds RC files for compilation.'
 
   def Run(self, opts, args):
     self.output_directory = '.'
     first_ids_file = None
     whitelist_filenames = []
     target_platform = None
-    (own_opts, args) = getopt.getopt(args, 'o:D:E:f:w:t:')
+    dep_dir = None
+    (own_opts, args) = getopt.getopt(args, 'o:D:E:f:w:t:', ('dep-dir=',))
     for (key, val) in own_opts:
       if key == '-o':
         self.output_directory = val
       elif key == '-D':
         name, val = util.ParseDefine(val)
         self.defines[name] = val
       elif key == '-E':
         (env_name, env_value) = val.split('=', 1)
         os.environ[env_name] = env_value
       elif key == '-f':
         # TODO(joi@chromium.org): Remove this override once change
         # lands in WebKit.grd to specify the first_ids_file in the
         # .grd itself.
         first_ids_file = val
       elif key == '-w':
         whitelist_filenames.append(val)
       elif key == '-t':
         target_platform = val
+      elif key == '--dep-dir':
+        dep_dir = val
 
     if len(args):
       print 'This tool takes no tool-specific arguments.'
       return 2
     self.SetOptions(opts)
     if self.scons_targets:
       self.VerboseOut('Using SCons targets to identify files to output.\n')
     else:
       self.VerboseOut('Output directory: %s (absolute path: %s)\n' %
                       (self.output_directory,
@@ skipping 10 matching lines @@
                                 debug=opts.extra_verbose,
                                 first_ids_file=first_ids_file,
                                 defines=self.defines,
                                 target_platform=target_platform)
     # Set an output context so that conditionals can use defines during the
     # gathering stage; we use a dummy language here since we are not outputting
     # a specific language.
     self.res.SetOutputLanguage('en')
     self.res.RunGatherers()
     self.Process()
+
+    if dep_dir:
+      self.GenerateDepfile(opts.input, dep_dir)
+
     return 0
 
   def __init__(self, defines=None):
     # Default file-creation function is built-in open().  Only done to allow
     # overriding by unit test.
     self.fo_create = open
 
     # key/value pairs of C-preprocessor like defines that are used for
     # conditional output of resources
     self.defines = defines or {}
@@ skipping 84 matching lines @@
       else:
         # TODO(gfeher) modify here to set utf-8 encoding for admx/adml
         encoding = 'utf_16'
 
       # Set the context, for conditional inclusion of resources
       self.res.SetOutputLanguage(output.GetLanguage())
       self.res.SetOutputContext(output.GetContext())
       self.res.SetDefines(self.defines)
 
       # Make the output directory if it doesn't exist.
-      outdir = os.path.split(output.GetOutputFilename())[0]
-      if not os.path.exists(outdir):
-        os.makedirs(outdir)
+      self.MakeDirectoriesTo(output.GetOutputFilename())
 
       # Write the results to a temporary file and only overwrite the original
       # if the file changed.  This avoids unnecessary rebuilds.
       outfile = self.fo_create(output.GetOutputFilename() + '.tmp', 'wb')
 
       if output.GetType() != 'data_package':
         outfile = util.WrapOutputStream(outfile, encoding)
 
       # Iterate in-order through entire resource tree, calling formatters on
       # the entry into a node and on exit out of it.
@@ skipping 30 matching lines @@
     # Print out any fallback warnings, and missing translation errors, and
     # exit with an error code if there are missing translations in a non-pseudo
     # and non-official build.
     warnings = (self.res.UberClique().MissingTranslationsReport().
         encode('ascii', 'replace'))
     if warnings:
       self.VerboseOut(warnings)
     if self.res.UberClique().HasMissingTranslations():
       print self.res.UberClique().missing_translations_
       sys.exit(-1)
+
+  def GenerateDepfile(self, input_filename, dep_dir):
+    '''Generate a depfile that contains the imlicit dependencies of the input
+    grd. The depfile will be in the same format as a makefile, and will contain
+    references to files relative to |dep_dir|. It will be put in the same
+    directory as the generated outputs.
+
+    For example, supposing we have three files in a directory src/
+
+    src/
+      blah.grd    <- depends on input{1,2}.xtb
+      input1.xtb
+      input2.xtb
+
+    and we run
+
+      grit -i blah.grd -o ../out/gen --dep-dir ../out
+
+    from the directory src/ we will generate a depfile ../out/gen/blah.grd.d
+    that has the contents
+
+      gen/blah.grd.d: ../src/input1.xtb ../src/input2.xtb
+
+    Note that all paths in the depfile are relative to ../out, the dep-dir.
+    '''
+    depsfile_basename = os.path.basename(input_filename + '.d')
+    depfile = os.path.abspath(
+        os.path.join(self.output_directory, depsfile_basename))
+    dep_dir = os.path.abspath(dep_dir)
+    # The path prefix to prepend to dependencies in the depfile.
+    prefix = os.path.relpath(os.getcwd(), dep_dir)
+    # The path that the depfile refers to itself by.
+    self_ref_depfile = os.path.relpath(depfile, dep_dir)
+    infiles = self.res.GetInputFiles()
+    deps_text = ' '.join([os.path.join(prefix, i) for i in infiles])
+    depfile_contents = self_ref_depfile + ': ' + deps_text
+    self.MakeDirectoriesTo(depfile)
+    outfile = self.fo_create(depfile, 'wb')
+    outfile.writelines(depfile_contents)

[Nico, 2013/12/31 01:07:42]

I'm currently looking at using this in gyp, and I'm wondering: Why does the flag
take a directory, not a path? As is, the generator or the gyp file will need to
know that the .d file is in os.path.join(dep_dir_path, grd_filename + '.d').
It'd be slightly nicer and simpler everywhere, if grit just got a --depfile
parameter instead of --dep-dir, no? Why was this design chosen?

+
+  @staticmethod
+  def MakeDirectoriesTo(file):
+    '''Creates directories necessary to contain |file|.'''
+    dir = os.path.split(file)[0]
+    if not os.path.exists(dir):
+      os.makedirs(dir)