eric: comparison DebugClients/Python3/coverage/files.py

-:456c58fc64b0
+:d0d6e4ad31bd
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
 """File wrangling."""
-from .backward import to_string
+import fnmatch
-from .misc import CoverageException
+import ntpath
-import fnmatch, os, os.path, re, sys
+import os
-import ntpath, posixpath
+import os.path
+import posixpath
-class FileLocator(object):
+import re
-"""Understand how filenames work."""
+import sys
-def __init__(self):
+from coverage import env
-# The absolute path to our current directory.
+from coverage.backward import unicode_class
-self.relative_dir = os.path.normcase(abs_file(os.curdir) + os.sep)
+from coverage.misc import CoverageException, join_regex
-# Cache of results of calling the canonical_filename() method, to
-# avoid duplicating work.
+RELATIVE_DIR = None
-self.canonical_filename_cache = {}
+CANONICAL_FILENAME_CACHE = {}
-def relative_filename(self, filename):
-"""Return the relative form of `filename`.
+def set_relative_directory():
+"""Set the directory that `relative_filename` will be relative to."""
-The filename will be relative to the current directory when the
+global RELATIVE_DIR, CANONICAL_FILENAME_CACHE
-`FileLocator` was constructed.
+# The absolute path to our current directory.
-"""
+RELATIVE_DIR = os.path.normcase(abs_file(os.curdir) + os.sep)
-fnorm = os.path.normcase(filename)
-if fnorm.startswith(self.relative_dir):
+# Cache of results of calling the canonical_filename() method, to
-filename = filename[len(self.relative_dir):]
+# avoid duplicating work.
-return filename
+CANONICAL_FILENAME_CACHE = {}
-def canonical_filename(self, filename):
+def relative_directory():
-"""Return a canonical filename for `filename`.
+"""Return the directory that `relative_filename` is relative to."""
+return RELATIVE_DIR
-An absolute path with no redundant components and normalized case.
+def relative_filename(filename):
-"""
+"""Return the relative form of `filename`.
-if filename not in self.canonical_filename_cache:
-if not os.path.isabs(filename):
+The file name will be relative to the current directory when the
-for path in [os.curdir] + sys.path:
+`set_relative_directory` was called.
-if path is None:
-continue
+"""
-f = os.path.join(path, filename)
+fnorm = os.path.normcase(filename)
-if os.path.exists(f):
+if fnorm.startswith(RELATIVE_DIR):
-filename = f
+filename = filename[len(RELATIVE_DIR):]
-break
+return filename
-cf = abs_file(filename)
-self.canonical_filename_cache[filename] = cf
+def canonical_filename(filename):
-return self.canonical_filename_cache[filename]
+"""Return a canonical file name for `filename`.
-def get_zip_data(self, filename):
+An absolute path with no redundant components and normalized case.
-"""Get data from `filename` if it is a zip file path.
+"""
-Returns the string data read from the zip file, or None if no zip file
+if filename not in CANONICAL_FILENAME_CACHE:
-could be found or `filename` isn't in it.  The data returned will be
+if not os.path.isabs(filename):
-an empty string if the file is empty.
+for path in [os.curdir] + sys.path:
+if path is None:
-"""
-import zipimport
-markers = ['.zip'+os.sep, '.egg'+os.sep]
-for marker in markers:
-if marker in filename:
-parts = filename.split(marker)
-try:
-zi = zipimport.zipimporter(parts[0]+marker[:-1])
-except zipimport.ZipImportError:
 continue
-try:
+f = os.path.join(path, filename)
-data = zi.get_data(parts[1])
+if os.path.exists(f):
-except IOError:
+filename = f
-continue
+break
-return to_string(data)
+cf = abs_file(filename)
-return None
+CANONICAL_FILENAME_CACHE[filename] = cf
+return CANONICAL_FILENAME_CACHE[filename]
-if sys.platform == 'win32':
+def flat_rootname(filename):
+"""A base for a flat file name to correspond to this file.
+Useful for writing files about the code where you want all the files in
+the same directory, but need to differentiate same-named files from
+different directories.
+For example, the file a/b/c.py will return 'a_b_c_py'
+"""
+name = ntpath.splitdrive(filename)[1]
+return re.sub(r"[\\/.:]", "_", name)
+if env.WINDOWS:
+_ACTUAL_PATH_CACHE = {}
+_ACTUAL_PATH_LIST_CACHE = {}
 def actual_path(path):
 """Get the actual path of `path`, including the correct case."""
-if path in actual_path.cache:
+if env.PY2 and isinstance(path, unicode_class):
-return actual_path.cache[path]
+path = path.encode(sys.getfilesystemencoding())
+if path in _ACTUAL_PATH_CACHE:
+return _ACTUAL_PATH_CACHE[path]
 head, tail = os.path.split(path)
 if not tail:
-actpath = head
+# This means head is the drive spec: normalize it.
+actpath = head.upper()
 elif not head:
 actpath = tail
 else:
 head = actual_path(head)
-if head in actual_path.list_cache:
+if head in _ACTUAL_PATH_LIST_CACHE:
-files = actual_path.list_cache[head]
+files = _ACTUAL_PATH_LIST_CACHE[head]
 else:
 try:
 files = os.listdir(head)
 except OSError:
 files = []
-actual_path.list_cache[head] = files
+_ACTUAL_PATH_LIST_CACHE[head] = files
 normtail = os.path.normcase(tail)
 for f in files:
 if os.path.normcase(f) == normtail:
 tail = f
 break
 actpath = os.path.join(head, tail)
-actual_path.cache[path] = actpath
+_ACTUAL_PATH_CACHE[path] = actpath
 return actpath
-actual_path.cache = {}
-actual_path.list_cache = {}
 else:
 def actual_path(filename):
 """The actual path for non-Windows platforms."""
 return filename
 If `patterns` is None, an empty list is returned.
 """
 prepped = []
 for p in patterns or []:
-if p.startswith("*") or p.startswith("?"):
+if 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[:]
+self.dirs = list(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):
 # This is a file in the directory
 return True
 return False
+class ModuleMatcher(object):
+"""A matcher for modules in a tree."""
+def __init__(self, module_names):
+self.modules = list(module_names)
+def __repr__(self):
+return "<ModuleMatcher %r>" % (self.modules)
+def info(self):
+"""A list of strings for displaying when dumping state."""
+return self.modules
+def match(self, module_name):
+"""Does `module_name` indicate a module in one of our packages?"""
+if not module_name:
+return False
+for m in self.modules:
+if module_name.startswith(m):
+if module_name == m:
+return True
+if module_name[len(m)] == '.':
+# This is a module in the package
+return True
+return False
 class FnmatchMatcher(object):
-"""A matcher for files by filename pattern."""
+"""A matcher for files by file name pattern."""
 def __init__(self, pats):
 self.pats = pats[:]
+# fnmatch is platform-specific. On Windows, it does the Windows thing
+# of treating / and \ as equivalent. But on other platforms, we need to
+# take care of that ourselves.
+fnpats = (fnmatch.translate(p) for p in pats)
+fnpats = (p.replace(r"\/", r"[\\/]") for p in fnpats)
+if env.WINDOWS:
+# Windows is also case-insensitive.  BTW: the regex docs say that
+# flags like (?i) have to be at the beginning, but fnmatch puts
+# them at the end, and having two there seems to work fine.
+fnpats = (p + "(?i)" for p in fnpats)
+self.re = re.compile(join_regex(fnpats))
 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?"""
+"""Does `fpath` match one of our file name patterns?"""
-for pat in self.pats:
+return self.re.match(fpath) is not None
-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."""
 sep_match = re.search(r"[\\/]", s)
 serialized checkouts on continuous integration machines.
 A `PathAliases` object tracks a list of pattern/result pairs, and can
 map a path through those aliases to produce a unified path.
-`locator` is a FileLocator that is used to canonicalize the results.
+"""
+def __init__(self):
-"""
-def __init__(self, locator=None):
 self.aliases = []
-self.locator = locator
 def add(self, pattern, result):
 """Add the `pattern`/`result` pair to the list of aliases.
 `pattern` is an `fnmatch`-style pattern.  `result` is a simple
 # 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
+# Make a regex from the pattern.  fnmatch always adds a \Z 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 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)
 Only one pattern is ever used.  If no patterns match, `path` is
 returned unchanged.
 The separator style in the result is made to match that of the result
 in the alias.
+Returns the mapped path.  If a mapping has happened, this is a
+canonical path.  If no mapping has happened, it is the original value
+of `path` unchanged.
 """
 for regex, result, pattern_sep, result_sep in self.aliases:
 m = regex.match(path)
 if m:
 new = path.replace(m.group(0), result)
 if pattern_sep != result_sep:
 new = new.replace(pattern_sep, result_sep)
-if self.locator:
+new = canonical_filename(new)
-new = self.locator.canonical_filename(new)
 return new
 return path
 def find_python_files(dirname):
 """Yield all of the importable Python files in `dirname`, recursively.
 To be importable, the files have to be in a directory with a __init__.py,
 except for `dirname` itself, which isn't required to have one.  The
 assumption is that `dirname` was specified directly, so the user knows
-best, but subdirectories are checked for a __init__.py to be sure we only
+best, but sub-directories are checked for a __init__.py to be sure we only
 find the importable files.
 """
 for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
 if i > 0 and '__init__.py' not in filenames:

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/coverage/files.py

DebugClients/Python3/coverage/files.py