Strip comments and whitespace from javascript resources

tools/grit/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 codecs
 import filecmp
 import getopt
 import os
 import shutil
 import sys
 
 from grit import grd_reader
 from grit import shortcuts
 from grit import util
 from grit.node import include
 from grit.node import message
 from grit.node import structure
 from grit.tool import interface
+from grit.format import minifier
 
 
 # It would be cleaner to have each module register itself, but that would
 # require importing all of them on every run of GRIT.
 '''Map from <output> node types to modules under grit.format.'''
 _format_modules = {
   'android':                  'android_xml',
   'c_format':                 'c_format',
   'chrome_messages_json':     'chrome_messages_json',
   'data_package':             'data_pack',
@@ skipping 85 matching lines @@
                     is different from the old file.  This allows some build
                     systems to realize that dependent build steps might be
                     unnecessary, at the cost of comparing the output data at
                     grit time.
 
   --depend-on-stamp
                     If specified along with --depfile and --depdir, the depfile
                     generated will depend on a stampfile instead of the first
                     output in the input .grd file.
 
+  --js-minifier     A command to run to minify Javascript. If not set then
+                    Javascript won't be minified. The command should read the
+                    original Javascript from standard input, and output the
+                    minified Javascript to standard output. A non-zero exit
+                    status will be taken as indicating failure.
+
 Conditional inclusion of resources only affects the output of files which
 control which resources get linked into a binary, e.g. it affects .rc files
 meant for compilation but it does not affect resource header files (that define
 IDs).  This helps ensure that values of IDs stay the same, that all messages
 are exported to translation interchange files (e.g. XMB files), etc.
 '''
 
   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 = []
     assert_output_files = []
     target_platform = None
     depfile = None
     depdir = None
     rc_header_format = None
     output_all_resource_defines = None
     write_only_new = False
     depend_on_stamp = False
+    js_minifier = None
     replace_ellipsis = True
     (own_opts, args) = getopt.getopt(args, 'a:o:D:E:f:w:t:h:',
         ('depdir=','depfile=','assert-file-list=',
          'output-all-resource-defines',
          'no-output-all-resource-defines',
          'no-replace-ellipsis',
          'depend-on-stamp',
+         'js-minifier=',
          'write-only-new='))
     for (key, val) in own_opts:
       if key == '-a':
         assert_output_files.append(val)
       elif key == '--assert-file-list':
         with open(val) as f:
           assert_output_files += f.read().splitlines()
       elif key == '-o':
         self.output_directory = val
       elif key == '-D':
@@ skipping 20 matching lines @@
       elif key == '-h':
         rc_header_format = val
       elif key == '--depdir':
         depdir = val
       elif key == '--depfile':
         depfile = val
       elif key == '--write-only-new':
         write_only_new = val != '0'
       elif key == '--depend-on-stamp':
         depend_on_stamp = True
+      elif key == '--js-minifier':
+        js_minifier = 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,
                        os.path.abspath(self.output_directory)))
 
     if whitelist_filenames:
       self.whitelist_names = set()
       for whitelist_filename in whitelist_filenames:
         self.VerboseOut('Using whitelist: %s\n' % whitelist_filename);
         whitelist_contents = util.ReadFile(whitelist_filename, util.RAW_TEXT)
         self.whitelist_names.update(whitelist_contents.strip().split('\n'))
 
+    if js_minifier:
+      minifier.SetJsMinifier(js_minifier)
+
     self.write_only_new = write_only_new
 
     self.res = grd_reader.Parse(opts.input,
                                 debug=opts.extra_verbose,
                                 first_ids_file=first_ids_file,
                                 defines=self.defines,
                                 target_platform=target_platform)
 
     # If the output_all_resource_defines option is specified, override the value
     # found in the grd file.
@@ skipping 274 matching lines @@
     self.MakeDirectoriesTo(depfile)
     outfile = self.fo_create(depfile, 'w', encoding='utf-8')
     outfile.writelines(depfile_contents)
 
   @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)