Correctly resolve relative paths when inlining @import directives in CSS files.

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 56 matching lines @@
     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)
-  filepath = os.path.join(base_path, filename)
+  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()]
@@ skipping 34 matching lines @@
 
   # 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):
+  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)
-    return os.path.join(input_filepath, 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)
       if begin_if is None:
@@ skipping 59 matching lines @@
 
   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)
 
-  def InlineCSSFile(src_match, inlined_files=inlined_files):
-    """Helper function to inline external css files.
+  def InlineCSSFile(src_match, pattern, base_path=input_filepath):
+    """Helper function to inline external CSS files.
 
     Args:
       src_match: A regular expression match with a named group named "filename".
+      pattern: The pattern to replace with the contents of the CSS file.
+      base_path: The base path to use for resolving the CSS file.
 
     Returns:
       The text that should replace the reference to the CSS file.
     """
-    filepath = GetFilepath(src_match)
+    filepath = GetFilepath(src_match, base_path)
     if filepath is None:
       return src_match.group(0)
 
     # Even if names_only is set, the CSS file needs to be opened, because it
     # can link to images that need to be added to the file set.
     inlined_files.add(filepath)
     # When resolving CSS files we need to pass in the path so that relative URLs
     # can be resolved.
-    return InlineCSSText(util.ReadFile(filepath, util.BINARY), filepath)
+    return pattern % InlineCSSText(util.ReadFile(filepath, util.BINARY),
+                                   filepath)
 
   def InlineCSSImages(text, filepath=input_filepath):
     """Helper function that inlines external images in CSS backgrounds."""
     # Replace contents of url() for css attributes: content, background,
     # or *-image.
     return re.sub('(content|background|[\w-]*-image):[^;]*' +
                   '(url\((?P<quote1>"|\'|)[^"\'()]*(?P=quote1)\)|' +
                       'image-set\(' +
                           '([ ]*url\((?P<quote2>"|\'|)[^"\'()]*(?P=quote2)\)' +
                               '[ ]*[0-9.]*x[ ]*(,[ ]*)?)+\))',
                   lambda m: InlineCSSUrls(m, filepath),
                   text)
 
   def InlineCSSUrls(src_match, filepath=input_filepath):
     """Helper function that inlines each url on a CSS image rule match."""
     # Replace contents of url() references in matches.
     return re.sub('url\((?P<quote>"|\'|)(?P<filename>[^"\'()]*)(?P=quote)\)',
                   lambda m: SrcReplace(m, filepath),
                   src_match.group(0))
 
   def InlineCSSImports(text, filepath=input_filepath):
     """Helper function that inlines CSS files included via the @import
        directive.
     """
     return re.sub('@import\s+url\((?P<quote>"|\'|)(?P<filename>[^"\'()]*)' +
-                  '(?P=quote)\)',
-                  InlineCSSFile,
+                  '(?P=quote)\);',
+                  lambda m: InlineCSSFile(m, '%s', filepath),
                   text)
 
 
   flat_text = util.ReadFile(input_filename, util.BINARY)
 
   # Check conditional elements, remove unsatisfied ones from the file. We do
   # this twice. The first pass is so that we don't even bother calling
   # InlineScript, InlineCSSFile and InlineIncludeFiles on text we're eventually
   # going to throw out anyway.
   flat_text = CheckConditionalElements(flat_text)
 
   if not allow_external_script:
     # We need to inline css and js before we inline images so that image
     # references gets inlined in the css and js
     flat_text = re.sub('<script (?P<attrs1>.*?)src="(?P<filename>[^"\']*)"' +
                        '(?P<attrs2>.*?)></script>',
                        InlineScript,
                        flat_text)
 
   flat_text = re.sub(
       '<link rel="stylesheet".+?href="(?P<filename>[^"]*)".*?>',
-      lambda m: '<style>%s</style>' % InlineCSSFile(m),
+      lambda m: InlineCSSFile(m, '<style>%s</style>'),
       flat_text)
 
   flat_text = re.sub(
       '<include\s+src="(?P<filename>[^"\']*)".*>',
       InlineIncludeFiles,
       flat_text)
 
   # Check conditional elements, second pass. This catches conditionals in any
   # of the text we just inlined.
   flat_text = CheckConditionalElements(flat_text)
@@ skipping 21 matching lines @@
 def InlineToString(input_filename, grd_node, allow_external_script=False,
                    rewrite_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
   """
-  return DoInline(input_filename,
-                  grd_node,
-                  allow_external_script=allow_external_script,
-                  rewrite_function=rewrite_function).inlined_data
+  try:
+    return DoInline(input_filename,
+                    grd_node,
+                    allow_external_script=allow_external_script,
+                    rewrite_function=rewrite_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:
@@ skipping 25 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()