Strip comments and whitespace from Javascript resources

tools/grit/grit/format/html_inline.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.
 
 """Flattens a HTML file by inlining its external resources.
 
 This is a small script that takes a HTML file, looks for src attributes
 and inlines the specified file, producing one HTML file with no external
 dependencies. It recursively inlines the included files.
@@ skipping 110 matching lines @@
   """Helper class holding the results from DoInline().
 
   Holds the inlined data and the set of filenames of all the inlined
   files.
   """
   def __init__(self, inlined_data, inlined_files):
     self.inlined_data = inlined_data
     self.inlined_files = inlined_files
 
 def DoInline(
-    input_filename, grd_node, allow_external_script=False,
+    input_filename, evaluate_condition, allow_external_script=False,
     preprocess_only=False, names_only=False, rewrite_function=None,
     filename_expansion_function=None):
   """Helper function that inlines the resources in a specified file.
 
   Reads input_filename, finds all the src attributes and attempts to
   inline the files they are referring to, then returns the result and
   the set of inlined files.
 
   Args:
     input_filename: name of file to read in
-    grd_node: html node from the grd file for this include tag
+    evaluate_condition: a function to evaluate boolean conditions

[Dan Beam, 2016/07/14 17:47:58]

this isn't really too helpful of a variable name, maybe expr_predicate or
something?

     preprocess_only: Skip all HTML processing, only handle <if> and <include>.
     names_only: |nil| will be returned for the inlined contents (faster).
     rewrite_function: function(filepath, text, distribution) which will be
         called to rewrite html content before inlining images.
     filename_expansion_function: function(filename) which will be called to
         rewrite filenames before attempting to read them.
   Returns:
     a tuple of the inlined data as a string and the set of filenames
     of all the inlined files
   """
@@ skipping 19 matching lines @@
       # filename is probably a URL, which we don't want to bother inlining
       return None
 
     filename = filename.replace('%DISTRIBUTION%', distribution)
     if filename_expansion_function:
       filename = filename_expansion_function(filename)
     return os.path.normpath(os.path.join(base_path, filename))
 
   def IsConditionSatisfied(src_match):
     expression = src_match.group('expression')
-    return grd_node is None or grd_node.EvaluateCondition(expression)
+    return evaluate_condition is None or evaluate_condition(expression)
 
   def CheckConditionalElements(str):
     """Helper function to conditionally inline inner elements"""
     while True:
       begin_if = _BEGIN_IF_BLOCK.search(str)
       if begin_if is None:
         if _END_IF_BLOCK.search(str) is not None:
           raise Exception('Unmatched </if>')
         return str
 
@@ skipping 36 matching lines @@
 
     if names_only:
       inlined_files.update(GetResourceFilenames(
           filepath,
           allow_external_script,
           rewrite_function,
           filename_expansion_function=filename_expansion_function))
       return ""
 
     return pattern % InlineToString(
-        filepath, grd_node, allow_external_script=allow_external_script,
+        filepath,
+        evaluate_condition,
+        allow_external_script=allow_external_script,
         filename_expansion_function=filename_expansion_function)
 
   def InlineIncludeFiles(src_match):
     """Helper function to directly inline generic external files (without
        wrapping them with any kind of tags).
     """
     return InlineFileContents(src_match, '%s')
 
   def InlineScript(match):
     """Helper function to inline external script files"""
     attrs = (match.group('attrs1') + match.group('attrs2')).strip()
     if attrs:
-       attrs = ' ' + attrs
+      attrs = ' ' + attrs
     return InlineFileContents(match, '<script' + attrs + '>%s</script>')
 
   def InlineCSSText(text, css_filepath):
     """Helper function that inlines external resources in CSS text"""
     filepath = os.path.dirname(css_filepath)
     # Allow custom modifications before inlining images.
     if rewrite_function:
       text = rewrite_function(filepath, text, distribution)
     text = InlineCSSImages(text, filepath)
     return InlineCSSImports(text, filepath)
@@ skipping 86 matching lines @@
     # TODO(arv): Only do this inside <style> tags.
     flat_text = InlineCSSImages(flat_text)
 
     flat_text = _ICON_RE.sub(SrcReplace, flat_text)
 
   if names_only:
     flat_text = None  # Will contains garbage if the flag is set anyway.
   return InlinedData(flat_text, inlined_files)
 
 
-def InlineToString(input_filename, grd_node, preprocess_only = False,
+def InlineToString(input_filename, evaluate_condition, preprocess_only = False,
                    allow_external_script=False, rewrite_function=None,
                    filename_expansion_function=None):
   """Inlines the resources in a specified file and returns it as a string.
 
   Args:
     input_filename: name of file to read in
-    grd_node: html node from the grd file for this include tag
+    evaluate_condition: a function to evaluate boolean conditions
   Returns:
     the inlined data as a string
   """
   try:
     return DoInline(
         input_filename,
-        grd_node,
+        evaluate_condition,
         preprocess_only=preprocess_only,
         allow_external_script=allow_external_script,
         rewrite_function=rewrite_function,
         filename_expansion_function=filename_expansion_function).inlined_data
   except IOError, e:
     raise Exception("Failed to open %s while trying to flatten %s. (%s)" %
                     (e.filename, input_filename, e.strerror))
 
 
-def InlineToFile(input_filename, output_filename, grd_node):
+def InlineToFile(input_filename, output_filename, evaluate_condition):
   """Inlines the resources in a specified file and writes it.
 
   Reads input_filename, finds all the src attributes and attempts to
   inline the files they are referring to, then writes the result
   to output_filename.
 
   Args:
     input_filename: name of file to read in
     output_filename: name of file to be written to
-    grd_node: html node from the grd file for this include tag
+    evaluate_condition: a function to evaluate boolean conditions
   Returns:
     a set of filenames of all the inlined files
   """
-  inlined_data = InlineToString(input_filename, grd_node)
+  inlined_data = InlineToString(input_filename, evaluate_condition)
   with open(output_filename, 'wb') as out_file:
     out_file.writelines(inlined_data)
 
 
 def GetResourceFilenames(filename,
                          allow_external_script=False,
                          rewrite_function=None,
                          filename_expansion_function=None):
   """For a grd file, returns a set of all the files that would be inline."""
   try:
@@ skipping 12 matching lines @@
 
 def main():
   if len(sys.argv) <= 2:
     print "Flattens a HTML file by inlining its external resources.\n"
     print "html_inline.py inputfile outputfile"
   else:
     InlineToFile(sys.argv[1], sys.argv[2], None)
 
 if __name__ == '__main__':
   main()