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 71 matching lines @@
   Returns:
     string
   """
   filename = src_match.group('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)

[flackr, 2013/06/06 14:07:19]

It looks to me like this won't do the filename replacement. You probably need to
pass the filename replacement function to this function or call GetFilePath for
each file result (probably better since it would use the same code).

Can you add an image to the test to verify?

[dconnelly, 2013/06/07 09:10:38]

Good catch, thanks.  I added the function parameter because src_match is an re
match object and not a string, so it can't be expanded before it's passed in.

   filepath = os.path.normpath(os.path.join(base_path, filename))
   inlined_files.add(filepath)
 
   if names_only:
     return ""
 
   mimetype = mimetypes.guess_type(filename)[0] or 'text/plain'
   inline_data = base64.standard_b64encode(util.ReadFile(filepath, util.BINARY))
 
   prefix = src_match.string[src_match.start():src_match.start('filename')]
   suffix = src_match.string[src_match.end('filename'):src_match.end()]
   return '%sdata:%s;base64,%s%s' % (prefix, mimetype, inline_data, suffix)
 
 
 class InlinedData:
   """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, 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)
 
   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()