Upgrade to coverage 3.7.1 and have it auto-build itself on first use.

third_party/coverage-3.7.1/coverage/files.py

 """File wrangling."""
 
 from coverage.backward import to_string
 from coverage.misc import CoverageException
 import fnmatch, os, os.path, re, sys
+import ntpath, posixpath
 
 class FileLocator(object):
     """Understand how filenames work."""
 
     def __init__(self):
         # The absolute path to our current directory.
         self.relative_dir = os.path.normcase(abs_file(os.curdir) + os.sep)
 
         # Cache of results of calling the canonical_filename() method, to
         # avoid duplicating work.
@@ skipping 87 matching lines @@
         return actpath
 
     actual_path.cache = {}
     actual_path.list_cache = {}
 
 else:
     def actual_path(filename):
         """The actual path for non-Windows platforms."""
         return filename
 
+
 def abs_file(filename):
     """Return the absolute normalized form of `filename`."""
-    path = os.path.abspath(os.path.realpath(filename))
+    path = os.path.expandvars(os.path.expanduser(filename))
+    path = os.path.abspath(os.path.realpath(path))
     path = actual_path(path)
     return path
 
 
+def isabs_anywhere(filename):
+    """Is `filename` an absolute path on any OS?"""
+    return ntpath.isabs(filename) or posixpath.isabs(filename)
+
+
 def prep_patterns(patterns):
     """Prepare the file patterns for use in a `FnmatchMatcher`.
 
     If a pattern starts with a wildcard, it is used as a pattern
     as-is.  If it does not start with a wildcard, then it is made
     absolute with the current directory.
 
     If `patterns` is None, an empty list is returned.
 
     """
-    patterns = patterns or []
     prepped = []
     for p in patterns or []:
         if p.startswith("*") or p.startswith("?"):
             prepped.append(p)
         else:
             prepped.append(abs_file(p))
     return prepped
 
 
 class TreeMatcher(object):
     """A matcher for files in a tree."""
     def __init__(self, directories):
         self.dirs = directories[:]
 
     def __repr__(self):
         return "<TreeMatcher %r>" % self.dirs
 
+    def info(self):
+        """A list of strings for displaying when dumping state."""
+        return self.dirs
+
     def add(self, directory):
         """Add another directory to the list we match for."""
         self.dirs.append(directory)
 
     def match(self, fpath):
         """Does `fpath` indicate a file in one of our trees?"""
         for d in self.dirs:
             if fpath.startswith(d):
                 if fpath == d:
                     # This is the same file!
                     return True
                 if fpath[len(d)] == os.sep:
                     # This is a file in the directory
                     return True
         return False
 
 
 class FnmatchMatcher(object):
     """A matcher for files by filename pattern."""
     def __init__(self, pats):
         self.pats = pats[:]
 
     def __repr__(self):
         return "<FnmatchMatcher %r>" % self.pats
 
+    def info(self):
+        """A list of strings for displaying when dumping state."""
+        return self.pats
+
     def match(self, fpath):
         """Does `fpath` match one of our filename patterns?"""
         for pat in self.pats:
             if fnmatch.fnmatch(fpath, pat):
                 return True
         return False
 
 
 def sep(s):
     """Find the path separator used in this string, or os.sep if none."""
@@ skipping 33 matching lines @@
 
         `pattern` can't end with a wildcard component, since that would
         match an entire tree, and not just its root.
 
         """
         # The pattern can't end with a wildcard component.
         pattern = pattern.rstrip(r"\/")
         if pattern.endswith("*"):
             raise CoverageException("Pattern must not end with wildcards.")
         pattern_sep = sep(pattern)
+
+        # The pattern is meant to match a filepath.  Let's make it absolute
+        # unless it already is, or is meant to match any prefix.
+        if not pattern.startswith('*') and not isabs_anywhere(pattern):
+            pattern = abs_file(pattern)
         pattern += pattern_sep
 
         # Make a regex from the pattern.  fnmatch always adds a \Z or $ to
         # match the whole string, which we don't want.
         regex_pat = fnmatch.translate(pattern).replace(r'\Z(', '(')
         if regex_pat.endswith("$"):
             regex_pat = regex_pat[:-1]
-        # We want */a/b.py to match on Windows to, so change slash to match
+        # We want */a/b.py to match on Windows too, so change slash to match
         # either separator.
         regex_pat = regex_pat.replace(r"\/", r"[\\/]")
         # We want case-insensitive matching, so add that flag.
         regex = re.compile(r"(?i)" + regex_pat)
 
         # Normalize the result: it must end with a path separator.
         result_sep = sep(result)
         result = result.rstrip(r"\/") + result_sep
         self.aliases.append((regex, result, pattern_sep, result_sep))
 
@@ skipping 32 matching lines @@
 
     """
     for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
         if i > 0 and '__init__.py' not in filenames:
             # If a directory doesn't have __init__.py, then it isn't
             # importable and neither are its files
             del dirnames[:]
             continue
         for filename in filenames:
             # We're only interested in files that look like reasonable Python
-            # files: Must end with .py, and must not have certain funny
+            # files: Must end with .py or .pyw, and must not have certain funny
             # characters that probably mean they are editor junk.
-            if re.match(r"^[^.#~!$@%^&*()+=,]+\.py$", filename):
+            if re.match(r"^[^.#~!$@%^&*()+=,]+\.pyw?$", filename):
                 yield os.path.join(dirpath, filename)