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

-:bedab77d0fa3
+:d6c795b5ce33
 # 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."""
+import hashlib
 import fnmatch
 import ntpath
 import os
 import os.path
 import posixpath
 if not os.path.isabs(filename):
 for path in [os.curdir] + sys.path:
 if path is None:
 continue
 f = os.path.join(path, filename)
-if os.path.exists(f):
+try:
+exists = os.path.exists(f)
+except UnicodeError:
+exists = False
+if exists:
 filename = f
 break
 cf = abs_file(filename)
 CANONICAL_FILENAME_CACHE[filename] = cf
 return CANONICAL_FILENAME_CACHE[filename]
+MAX_FLAT = 200
+@contract(filename='unicode', returns='unicode')
 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
 For example, the file a/b/c.py will return 'a_b_c_py'
 """
 name = ntpath.splitdrive(filename)[1]
-return re.sub(r"[\\/.:]", "_", name)
+name = re.sub(r"[\\/.:]", "_", name)
+if len(name) > MAX_FLAT:
+h = hashlib.sha1(name.encode('UTF-8')).hexdigest()
+name = name[-(MAX_FLAT-len(h)-1):] + '_' + h
+return name
 if env.WINDOWS:
 _ACTUAL_PATH_CACHE = {}
 @contract(returns='unicode')
 def abs_file(filename):
 """Return the absolute normalized form of `filename`."""
 path = os.path.expandvars(os.path.expanduser(filename))
-path = os.path.abspath(os.path.realpath(path))
+try:
+path = os.path.realpath(path)
+except UnicodeError:
+pass
+path = os.path.abspath(path)
 path = actual_path(path)
 path = unicode_filename(path)
 return path
 prepped.append(abs_file(p))
 return prepped
 class TreeMatcher(object):
-"""A matcher for files in a tree."""
+"""A matcher for files in a tree.
-def __init__(self, directories):
-self.dirs = list(directories)
+Construct with a list of paths, either files or directories. Paths match
+with the `match` method if they are one of the files, or if they are
+somewhere in a subtree rooted at one of the directories.
+"""
+def __init__(self, paths):
+self.paths = list(paths)
 def __repr__(self):
-return "<TreeMatcher %r>" % self.dirs
+return "<TreeMatcher %r>" % self.paths
 def info(self):
 """A list of strings for displaying when dumping state."""
-return self.dirs
+return self.paths
 def match(self, fpath):
 """Does `fpath` indicate a file in one of our trees?"""
-for d in self.dirs:
+for p in self.paths:
-if fpath.startswith(d):
+if fpath.startswith(p):
-if fpath == d:
+if fpath == p:
 # This is the same file!
 return True
-if fpath[len(d)] == os.sep:
+if fpath[len(p)] == os.sep:
 # This is a file in the directory
 return True
 return False
 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)
+# Python3.7 fnmatch translates "/" as "/", before that, it translates as "\/",
+# so we have to deal with maybe a backslash.
+fnpats = (re.sub(r"\\?/", r"[\\\\/]", p) for p in fnpats)
+flags = 0
 if env.WINDOWS:
-# Windows is also case-insensitive.  BTW: the regex docs say that
+# Windows is also case-insensitive, so make the regex case-insensitive.
-# flags like (?i) have to be at the beginning, but fnmatch puts
+flags |= re.IGNORECASE
-# them at the end, and having two there seems to work fine.
+self.re = re.compile(join_regex(fnpats), flags=flags)
-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):
 """
 def __init__(self):
 self.aliases = []
+def pprint(self):       # pragma: debugging
+"""Dump the important parts of the PathAliases, for debugging."""
+for regex, result in self.aliases:
+print("{0!r} --> {1!r}".format(regex.pattern, result))
 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
 string.  When mapping paths, if a path starts with a match against
 `pattern` can't end with a wildcard component, since that would
 match an entire tree, and not just its root.
 """
+if len(pattern) > 1:
+pattern = pattern.rstrip(r"\/")
 # 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
+if not pattern.endswith(pattern_sep):
+pattern += pattern_sep
 # Make a regex from the pattern.  fnmatch always adds a \Z to
-# match the whole string, which we don't want.
+# match the whole string, which we don't want, so we remove the \Z.
-regex_pat = fnmatch.translate(pattern).replace(r'\Z(', '(')
+# While removing it, we only replace \Z if followed by paren, or at
+# end, to keep from destroying a literal \Z in the pattern.
+regex_pat = fnmatch.translate(pattern)
+regex_pat = re.sub(r'\\Z(\(|$)', r'\1', regex_pat)
 # 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))
+self.aliases.append((regex, result))
 def map(self, path):
 """Map `path` through the aliases.
 `path` is checked against all of the patterns.  The first pattern to
 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:
+for regex, result in self.aliases:
 m = regex.match(path)
 if m:
 new = path.replace(m.group(0), result)
-if pattern_sep != result_sep:
+new = new.replace(sep(path), sep(result))
-new = new.replace(pattern_sep, result_sep)
 new = canonical_filename(new)
 return new
 return path

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/files.py

DebugClients/Python/coverage/files.py