GRIT: Enable variable expansion in filenames during HTML inlining.

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 54 matching lines @@
   """
   distribution = DIST_DEFAULT
   if DIST_ENV_VAR in os.environ.keys():
     distribution = os.environ[DIST_ENV_VAR]
     if len(distribution) > 1 and distribution[0] == '_':
       distribution = distribution[1:].lower()
   return distribution
 
 
 def SrcInlineAsDataURL(
-    src_match, base_path, distribution, inlined_files, names_only=False):
+    src_match, base_path, distribution, inlined_files, names_only=False,
+    filename_expansion_function=None):
   """regex replace function.
 
   Takes a regex match for src="filename", attempts to read the file
   at 'filename' and returns the src attribute with the file inlined
   as a data URI. If it finds DIST_SUBSTR string in file name, replaces
   it with distribution.
 
   Args:
     src_match: regex match object with 'filename' and 'quote' named capturing
                groups
     base_path: path that to look for files in
     distribution: string that should replace DIST_SUBSTR
     inlined_files: The name of the opened file is appended to this list.
     names_only: If true, the function will not read the file but just return "".
                 It will still add the filename to |inlined_files|.
 
   Returns:
     string
   """
   filename = src_match.group('filename')
+  if filename_expansion_function:
+    filename = filename_expansion_function(filename)
   quote = src_match.group('quote')
 
   if filename.find(':') != -1:
     # filename is probably a URL, which we don't want to bother inlining
     return src_match.group(0)
 
   filename = filename.replace(DIST_SUBSTR , distribution)
   filepath = os.path.normpath(os.path.join(base_path, filename))
   inlined_files.add(filepath)
 
@@ skipping 13 matching lines @@
 
   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, names_only=False,
-    rewrite_function=None):
+    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
     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
   """
+  if filename_expansion_function:
+    input_filename = filename_expansion_function(input_filename)
   input_filepath = os.path.dirname(input_filename)
   distribution = GetDistribution()
 
   # Keep track of all the files we inline.
   inlined_files = set()
 
   def SrcReplace(src_match, filepath=input_filepath,
                  inlined_files=inlined_files):
     """Helper function to provide SrcInlineAsDataURL with the base file path"""
     return SrcInlineAsDataURL(
-        src_match, filepath, distribution, inlined_files, names_only=names_only)
+        src_match, filepath, distribution, inlined_files, names_only=names_only,
+        filename_expansion_function=filename_expansion_function)
 
   def GetFilepath(src_match, base_path = input_filepath):
     filename = src_match.group('filename')
 
     if filename.find(':') != -1:
       # 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)
 
   def CheckConditionalElements(str):
     """Helper function to conditionally inline inner elements"""
     while True:
       begin_if = _BEGIN_IF_BLOCK.search(str)
@@ skipping 31 matching lines @@
         str = leading + trailing
 
   def InlineFileContents(src_match, pattern, inlined_files=inlined_files):
     """Helper function to inline external files of various types"""
     filepath = GetFilepath(src_match)
     if filepath is None:
       return src_match.group(0)
     inlined_files.add(filepath)
 
     if names_only:
-      inlined_files.update(GetResourceFilenames(filepath,
-                                                allow_external_script,
-                                                rewrite_function))
+      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)
+    return pattern % InlineToString(
+        filepath, grd_node, 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()
@@ skipping 98 matching lines @@
   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, allow_external_script=False,
-                   rewrite_function=None):
+                   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
   Returns:
     the inlined data as a string
   """
   try:
-    return DoInline(input_filename,
-                    grd_node,
-                    allow_external_script=allow_external_script,
-                    rewrite_function=rewrite_function).inlined_data
+    return DoInline(
+        input_filename,
+        grd_node,
+        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):
   """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
   Returns:
     a set of filenames of all the inlined files
   """
   inlined_data = InlineToString(input_filename, grd_node)
   with open(output_filename, 'wb') as out_file:
     out_file.writelines(inlined_data)
 
 
 def GetResourceFilenames(filename,
                          allow_external_script=False,
-                         rewrite_function=None):
+                         rewrite_function=None,
+                         filename_expansion_function=None):
   """For a grd file, returns a set of all the files that would be inline."""
   try:
-    return DoInline(filename,
-                    None,
-                    names_only=True,
-                    allow_external_script=allow_external_script,
-                    rewrite_function=rewrite_function).inlined_files
+    return DoInline(
+        filename,
+        None,
+        names_only=True,
+        allow_external_script=allow_external_script,
+        rewrite_function=rewrite_function,
+        filename_expansion_function=filename_expansion_function).inlined_files
   except IOError, e:
     raise Exception("Failed to open %s while trying to flatten %s. (%s)" %
                     (e.filename, filename, e.strerror))
 
 
 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()