posix: do not use fstat in isowner

The fstat function was undefined, but never used since a stat object
was always passed in the optional st argument. Passing st is now
mandatory.

This bug crept in when util was split up into posix and windows
modules. The fstat function is still defined in util, but importing it
into posix would create an import cycle which seems unnecessary.

mercurial/posix.py

@@ -1,219 +1,214 b''
 # posix.py - Posix utility function implementations for Mercurial
 #
 #  Copyright 2005-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from i18n import _
 import osutil
 import os, sys, errno, stat, getpass, pwd, grp
 
 posixfile = file
 nulldev = '/dev/null'
 normpath = os.path.normpath
 samestat = os.path.samestat
 expandglobs = False
 
 umask = os.umask(0)
 os.umask(umask)
 
 def openhardlinks():
     '''return true if it is safe to hold open file handles to hardlinks'''
     return True
 
 def rcfiles(path):
     rcs = [os.path.join(path, 'hgrc')]
     rcdir = os.path.join(path, 'hgrc.d')
     try:
         rcs.extend([os.path.join(rcdir, f)
                     for f, kind in osutil.listdir(rcdir)
                     if f.endswith(".rc")])
     except OSError:
         pass
     return rcs
 
 def system_rcpath():
     path = []
     # old mod_python does not set sys.argv
     if len(getattr(sys, 'argv', [])) > 0:
         path.extend(rcfiles(os.path.dirname(sys.argv[0]) +
                               '/../etc/mercurial'))
     path.extend(rcfiles('/etc/mercurial'))
     return path
 
 def user_rcpath():
     return [os.path.expanduser('~/.hgrc')]
 
 def parse_patch_output(output_line):
     """parses the output produced by patch and returns the file name"""
     pf = output_line[14:]
     if os.sys.platform == 'OpenVMS':
         if pf[0] == '`':
             pf = pf[1:-1] # Remove the quotes
     else:
         if pf.startswith("'") and pf.endswith("'") and " " in pf:
             pf = pf[1:-1] # Remove the quotes
     return pf
 
 def sshargs(sshcmd, host, user, port):
     '''Build argument list for ssh'''
     args = user and ("%s@%s" % (user, host)) or host
     return port and ("%s -p %s" % (args, port)) or args
 
 def is_exec(f):
     """check whether a file is executable"""
     return (os.lstat(f).st_mode & 0100 != 0)
 
 def set_flags(f, l, x):
     s = os.lstat(f).st_mode
     if l:
         if not stat.S_ISLNK(s):
             # switch file to link
             data = file(f).read()
             os.unlink(f)
             try:
                 os.symlink(data, f)
             except:
                 # failed to make a link, rewrite file
                 file(f, "w").write(data)
         # no chmod needed at this point
         return
     if stat.S_ISLNK(s):
         # switch link to file
         data = os.readlink(f)
         os.unlink(f)
         file(f, "w").write(data)
         s = 0666 & ~umask # avoid restatting for chmod
 
     sx = s & 0100
     if x and not sx:
         # Turn on +x for every +r bit when making a file executable
         # and obey umask.
         os.chmod(f, s | (s & 0444) >> 2 & ~umask)
     elif not x and sx:
         # Turn off all +x bits
         os.chmod(f, s & 0666)
 
 def set_binary(fd):
     pass
 
 def pconvert(path):
     return path
 
 def localpath(path):
     return path
 
 def shellquote(s):
     if os.sys.platform == 'OpenVMS':
         return '"%s"' % s
     else:
         return "'%s'" % s.replace("'", "'\\''")
 
 def quotecommand(cmd):
     return cmd
 
 def popen(command, mode='r'):
     return os.popen(command, mode)
 
 def testpid(pid):
     '''return False if pid dead, True if running or not sure'''
     if os.sys.platform == 'OpenVMS':
         return True
     try:
         os.kill(pid, 0)
         return True
     except OSError, inst:
         return inst.errno != errno.ESRCH
 
 def explain_exit(code):
     """return a 2-tuple (desc, code) describing a process's status"""
     if os.WIFEXITED(code):
         val = os.WEXITSTATUS(code)
         return _("exited with status %d") % val, val
     elif os.WIFSIGNALED(code):
         val = os.WTERMSIG(code)
         return _("killed by signal %d") % val, val
     elif os.WIFSTOPPED(code):
         val = os.WSTOPSIG(code)
         return _("stopped by signal %d") % val, val
     raise ValueError(_("invalid exit code"))
 
-def isowner(fp, st=None):
-    """Return True if the file object f belongs to the current user.
-
-    The return value of a util.fstat(f) may be passed as the st argument.
-    """
-    if st is None:
-        st = fstat(fp)
+def isowner(st):
+    """Return True if the stat object st is from the current user."""
     return st.st_uid == os.getuid()
 
 def find_exe(command):
     '''Find executable for command searching like which does.
     If command is a basename then PATH is searched for command.
     PATH isn't searched if command is an absolute or relative path.
     If command isn't found None is returned.'''
     if sys.platform == 'OpenVMS':
         return command
 
     def findexisting(executable):
         'Will return executable if existing file'
         if os.path.exists(executable):
             return executable
         return None
 
     if os.sep in command:
         return findexisting(command)
 
     for path in os.environ.get('PATH', '').split(os.pathsep):
         executable = findexisting(os.path.join(path, command))
         if executable is not None:
             return executable
     return None
 
 def set_signal_handler():
     pass
 
 def statfiles(files):
     'Stat each file in files and yield stat or None if file does not exist.'
     lstat = os.lstat
     for nf in files:
         try:
             st = lstat(nf)
         except OSError, err:
             if err.errno not in (errno.ENOENT, errno.ENOTDIR):
                 raise
             st = None
         yield st
 
 def getuser():
     '''return name of current user'''
     return getpass.getuser()
 
 def expand_glob(pats):
     '''On Windows, expand the implicit globs in a list of patterns'''
     return list(pats)
 
 def username(uid=None):
     """Return the name of the user with the given uid.
 
     If uid is None, return the name of the current user."""
 
     if uid is None:
         uid = os.getuid()
     try:
         return pwd.getpwuid(uid)[0]
     except KeyError:
         return str(uid)
 
 def groupname(gid=None):
     """Return the name of the group with the given gid.
 
     If gid is None, return the name of the current group."""
 
     if gid is None:
         gid = os.getgid()
     try:
         return grp.getgrgid(gid)[0]
     except KeyError:
         return str(gid)

mercurial/ui.py

@@ -1,346 +1,346 b''
 # ui.py - user interface bits for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from i18n import _
 import errno, getpass, os, socket, sys, tempfile, traceback
 import config, util, error
 
 _booleans = {'1': True, 'yes': True, 'true': True, 'on': True,
              '0': False, 'no': False, 'false': False, 'off': False}
 
 class ui(object):
     def __init__(self, src=None):
         self._buffers = []
         self.quiet = self.verbose = self.debugflag = self._traceback = False
         self._reportuntrusted = True
         self._ocfg = config.config() # overlay
         self._tcfg = config.config() # trusted
         self._ucfg = config.config() # untrusted
         self._trustusers = set()
         self._trustgroups = set()
 
         if src:
             self._tcfg = src._tcfg.copy()
             self._ucfg = src._ucfg.copy()
             self._ocfg = src._ocfg.copy()
             self._trustusers = src._trustusers.copy()
             self._trustgroups = src._trustgroups.copy()
             self.fixconfig()
         else:
             # we always trust global config files
             for f in util.rcpath():
                 self.readconfig(f, trust=True)
 
     def copy(self):
         return self.__class__(self)
 
     def _is_trusted(self, fp, f):
         st = util.fstat(fp)
-        if util.isowner(fp, st):
+        if util.isowner(st):
             return True
 
         tusers, tgroups = self._trustusers, self._trustgroups
         if '*' in tusers or '*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self._reportuntrusted:
             self.warn(_('Not trusting file %s from untrusted '
                         'user %s, group %s\n') % (f, user, group))
         return False
 
     def readconfig(self, filename, root=None, trust=False,
                    sections=None, remap=None):
         try:
             fp = open(filename)
         except IOError:
             if not sections: # ignore unless we were looking for something
                 return
             raise
 
         cfg = config.config()
         trusted = sections or trust or self._is_trusted(fp, filename)
 
         try:
             cfg.read(filename, fp, sections=sections, remap=remap)
         except error.ConfigError, inst:
             if trusted:
                 raise
             self.warn(_("Ignored: %s\n") % str(inst))
 
         if trusted:
             self._tcfg.update(cfg)
             self._tcfg.update(self._ocfg)
         self._ucfg.update(cfg)
         self._ucfg.update(self._ocfg)
 
         if root is None:
             root = os.path.expanduser('~')
         self.fixconfig(root=root)
 
     def fixconfig(self, root=None):
         # translate paths relative to root (or home) into absolute paths
         root = root or os.getcwd()
         for c in self._tcfg, self._ucfg, self._ocfg:
             for n, p in c.items('paths'):
                 if p and "://" not in p and not os.path.isabs(p):
                     c.set("paths", n, os.path.normpath(os.path.join(root, p)))
 
         # update ui options
         self.debugflag = self.configbool('ui', 'debug')
         self.verbose = self.debugflag or self.configbool('ui', 'verbose')
         self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
         if self.verbose and self.quiet:
             self.quiet = self.verbose = False
         self._reportuntrusted = self.configbool("ui", "report_untrusted", True)
         self._traceback = self.configbool('ui', 'traceback', False)
 
         # update trust information
         self._trustusers.update(self.configlist('trusted', 'users'))
         self._trustgroups.update(self.configlist('trusted', 'groups'))
 
     def setconfig(self, section, name, value):
         for cfg in (self._ocfg, self._tcfg, self._ucfg):
             cfg.set(section, name, value)
         self.fixconfig()
 
     def _data(self, untrusted):
         return untrusted and self._ucfg or self._tcfg
 
     def configsource(self, section, name, untrusted=False):
         return self._data(untrusted).source(section, name) or 'none'
 
     def config(self, section, name, default=None, untrusted=False):
         value = self._data(untrusted).get(section, name, default)
         if self.debugflag and not untrusted and self._reportuntrusted:
             uvalue = self._ucfg.get(section, name)
             if uvalue is not None and uvalue != value:
                 self.debug(_("ignoring untrusted configuration option "
                              "%s.%s = %s\n") % (section, name, uvalue))
         return value
 
     def configbool(self, section, name, default=False, untrusted=False):
         v = self.config(section, name, None, untrusted)
         if v is None:
             return default
         if v.lower() not in _booleans:
             raise error.ConfigError(_("%s.%s not a boolean ('%s')")
                                     % (section, name, v))
         return _booleans[v.lower()]
 
     def configlist(self, section, name, default=None, untrusted=False):
         """Return a list of comma/space separated strings"""
         result = self.config(section, name, untrusted=untrusted)
         if result is None:
             result = default or []
         if isinstance(result, basestring):
             result = result.replace(",", " ").split()
         return result
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         return section in self._data(untrusted)
 
     def configitems(self, section, untrusted=False):
         items = self._data(untrusted).items(section)
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in self._ucfg.items(section):
                 if self._tcfg.get(section, k) != v:
                     self.debug(_("ignoring untrusted configuration option "
                                 "%s.%s = %s\n") % (section, k, v))
         return items
 
     def walkconfig(self, untrusted=False):
         cfg = self._data(untrusted)
         for section in cfg.sections():
             for name, value in self.configitems(section, untrusted):
                 yield section, name, str(value).replace('\n', '\\n')
 
     def username(self):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         """
         user = os.environ.get("HGUSER")
         if user is None:
             user = self.config("ui", "username")
         if user is None:
             user = os.environ.get("EMAIL")
         if user is None and self.configbool("ui", "askusername"):
             user = self.prompt(_("enter a commit username:"), default=None)
         if user is None:
             try:
                 user = '%s@%s' % (util.getuser(), socket.getfqdn())
                 self.warn(_("No username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise util.Abort(_("Please specify a username."))
         if "\n" in user:
             raise util.Abort(_("username %s contains a newline\n") % repr(user))
         return user
 
     def shortuser(self, user):
         """Return a short representation of a user name or email address."""
         if not self.verbose: user = util.shortuser(user)
         return user
 
     def _path(self, loc):
         p = self.config('paths', loc)
         if p and '%%' in p:
             self.warn('(deprecated \'%%\' in path %s=%s from %s)\n' %
                     (loc, p, self.configsource('paths', loc)))
             p = p.replace('%%', '%')
         return p
 
     def expandpath(self, loc, default=None):
         """Return repository location relative to cwd or from [paths]"""
         if "://" in loc or os.path.isdir(os.path.join(loc, '.hg')):
             return loc
 
         path = self._path(loc)
         if not path and default is not None:
             path = self._path(default)
         return path or loc
 
     def pushbuffer(self):
         self._buffers.append([])
 
     def popbuffer(self):
         return "".join(self._buffers.pop())
 
     def write(self, *args):
         if self._buffers:
             self._buffers[-1].extend([str(a) for a in args])
         else:
             for a in args:
                 sys.stdout.write(str(a))
 
     def write_err(self, *args):
         try:
             if not sys.stdout.closed: sys.stdout.flush()
             for a in args:
                 sys.stderr.write(str(a))
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if not sys.stderr.closed: sys.stderr.flush()
         except IOError, inst:
             if inst.errno != errno.EPIPE:
                 raise
 
     def flush(self):
         try: sys.stdout.flush()
         except: pass
         try: sys.stderr.flush()
         except: pass
 
     def interactive(self):
         i = self.configbool("ui", "interactive", None)
         if i is None:
             return sys.stdin.isatty()
         return i
 
     def _readline(self, prompt=''):
         if sys.stdin.isatty():
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 pass
         line = raw_input(prompt)
         # When stdin is in binary mode on Windows, it can cause
         # raw_input() to emit an extra trailing carriage return
         if os.linesep == '\r\n' and line and line[-1] == '\r':
             line = line[:-1]
         return line
 
     def prompt(self, msg, choices=None, default="y"):
         """Prompt user with msg, read response, and ensure it matches
         one of the provided choices. choices is a sequence of acceptable
         responses with the format: ('&None', 'E&xec', 'Sym&link')
         No sequence implies no response checking. Responses are case
         insensitive. If ui is not interactive, the default is returned.
         """
         if not self.interactive():
             self.note(msg, ' ', default, "\n")
             return default
         while True:
             try:
                 r = self._readline(msg + ' ')
                 if not r:
                     return default
                 if not choices:
                     return r
                 resps = [s[s.index('&')+1].lower() for s in choices]
                 if r.lower() in resps:
                     return r.lower()
                 else:
                     self.write(_("unrecognized response\n"))
             except EOFError:
                 raise util.Abort(_('response expected'))
 
     def getpass(self, prompt=None, default=None):
         if not self.interactive(): return default
         try:
             return getpass.getpass(prompt or _('password: '))
         except EOFError:
             raise util.Abort(_('response expected'))
     def status(self, *msg):
         if not self.quiet: self.write(*msg)
     def warn(self, *msg):
         self.write_err(*msg)
     def note(self, *msg):
         if self.verbose: self.write(*msg)
     def debug(self, *msg):
         if self.debugflag: self.write(*msg)
     def edit(self, text, user):
         (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt",
                                       text=True)
         try:
             f = os.fdopen(fd, "w")
             f.write(text)
             f.close()
 
             editor = self.geteditor()
 
             util.system("%s \"%s\"" % (editor, name),
                         environ={'HGUSER': user},
                         onerr=util.Abort, errprefix=_("edit failed"))
 
             f = open(name)
             t = f.read()
             f.close()
         finally:
             os.unlink(name)
 
         return t
 
     def traceback(self):
         '''print exception traceback if traceback printing enabled.
         only to call in exception handler. returns true if traceback
         printed.'''
         if self._traceback:
             traceback.print_exc()
         return self._traceback
 
     def geteditor(self):
         '''return editor to use'''
         return (os.environ.get("HGEDITOR") or
                 self.config("ui", "editor") or
                 os.environ.get("VISUAL") or
                 os.environ.get("EDITOR", "vi"))

mercurial/windows.py

@@ -1,284 +1,284 b''
 # windows.py - Windows utility function implementations for Mercurial
 #
 #  Copyright 2005-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from i18n import _
 import osutil, error
 import errno, msvcrt, os, re, sys
 
 nulldev = 'NUL:'
 umask = 002
 
 # wrap osutil.posixfile to provide friendlier exceptions
 def posixfile(name, mode='r', buffering=-1):
     try:
         return osutil.posixfile(name, mode, buffering)
     except WindowsError, err:
         raise WinIOError(err)
 posixfile.__doc__ = osutil.posixfile.__doc__
 
 class winstdout:
     '''stdout on windows misbehaves if sent through a pipe'''
 
     def __init__(self, fp):
         self.fp = fp
 
     def __getattr__(self, key):
         return getattr(self.fp, key)
 
     def close(self):
         try:
             self.fp.close()
         except: pass
 
     def write(self, s):
         try:
             # This is workaround for "Not enough space" error on
             # writing large size of data to console.
             limit = 16000
             l = len(s)
             start = 0
             while start < l:
                 end = start + limit
                 self.fp.write(s[start:end])
                 start = end
         except IOError, inst:
             if inst.errno != 0: raise
             self.close()
             raise IOError(errno.EPIPE, 'Broken pipe')
 
     def flush(self):
         try:
             return self.fp.flush()
         except IOError, inst:
             if inst.errno != errno.EINVAL: raise
             self.close()
             raise IOError(errno.EPIPE, 'Broken pipe')
 
 sys.stdout = winstdout(sys.stdout)
 
 def _is_win_9x():
     '''return true if run on windows 95, 98 or me.'''
     try:
         return sys.getwindowsversion()[3] == 1
     except AttributeError:
         return 'command' in os.environ.get('comspec', '')
 
 def openhardlinks():
     return not _is_win_9x() and "win32api" in globals()
 
 def system_rcpath():
     try:
         return system_rcpath_win32()
     except:
         return [r'c:\mercurial\mercurial.ini']
 
 def user_rcpath():
     '''return os-specific hgrc search path to the user dir'''
     try:
         path = user_rcpath_win32()
     except:
         home = os.path.expanduser('~')
         path = [os.path.join(home, 'mercurial.ini'),
                 os.path.join(home, '.hgrc')]
     userprofile = os.environ.get('USERPROFILE')
     if userprofile:
         path.append(os.path.join(userprofile, 'mercurial.ini'))
         path.append(os.path.join(userprofile, '.hgrc'))
     return path
 
 def parse_patch_output(output_line):
     """parses the output produced by patch and returns the file name"""
     pf = output_line[14:]
     if pf[0] == '`':
         pf = pf[1:-1] # Remove the quotes
     return pf
 
 def sshargs(sshcmd, host, user, port):
     '''Build argument list for ssh or Plink'''
     pflag = 'plink' in sshcmd.lower() and '-P' or '-p'
     args = user and ("%s@%s" % (user, host)) or host
     return port and ("%s %s %s" % (args, pflag, port)) or args
 
 def testpid(pid):
     '''return False if pid dead, True if running or not known'''
     return True
 
 def set_flags(f, l, x):
     pass
 
 def set_binary(fd):
     # When run without console, pipes may expose invalid
     # fileno(), usually set to -1.
     if hasattr(fd, 'fileno') and fd.fileno() >= 0:
         msvcrt.setmode(fd.fileno(), os.O_BINARY)
 
 def pconvert(path):
     return '/'.join(path.split(os.sep))
 
 def localpath(path):
     return path.replace('/', '\\')
 
 def normpath(path):
     return pconvert(os.path.normpath(path))
 
 def samestat(s1, s2):
     return False
 
 # A sequence of backslashes is special iff it precedes a double quote:
 # - if there's an even number of backslashes, the double quote is not
 #   quoted (i.e. it ends the quoted region)
 # - if there's an odd number of backslashes, the double quote is quoted
 # - in both cases, every pair of backslashes is unquoted into a single
 #   backslash
 # (See http://msdn2.microsoft.com/en-us/library/a1y7w461.aspx )
 # So, to quote a string, we must surround it in double quotes, double
 # the number of backslashes that preceed double quotes and add another
 # backslash before every double quote (being careful with the double
 # quote we've appended to the end)
 _quotere = None
 def shellquote(s):
     global _quotere
     if _quotere is None:
         _quotere = re.compile(r'(\\*)("|\\$)')
     return '"%s"' % _quotere.sub(r'\1\1\\\2', s)
 
 def quotecommand(cmd):
     """Build a command string suitable for os.popen* calls."""
     # The extra quotes are needed because popen* runs the command
     # through the current COMSPEC. cmd.exe suppress enclosing quotes.
     return '"' + cmd + '"'
 
 def popen(command, mode='r'):
     # Work around "popen spawned process may not write to stdout
     # under windows"
     # http://bugs.python.org/issue1366
     command += " 2> %s" % nulldev
     return os.popen(quotecommand(command), mode)
 
 def explain_exit(code):
     return _("exited with status %d") % code, code
 
 # if you change this stub into a real check, please try to implement the
 # username and groupname functions above, too.
-def isowner(fp, st=None):
+def isowner(st):
     return True
 
 def find_exe(command):
     '''Find executable for command searching like cmd.exe does.
     If command is a basename then PATH is searched for command.
     PATH isn't searched if command is an absolute or relative path.
     An extension from PATHEXT is found and added if not present.
     If command isn't found None is returned.'''
     pathext = os.environ.get('PATHEXT', '.COM;.EXE;.BAT;.CMD')
     pathexts = [ext for ext in pathext.lower().split(os.pathsep)]
     if os.path.splitext(command)[1].lower() in pathexts:
         pathexts = ['']
 
     def findexisting(pathcommand):
         'Will append extension (if needed) and return existing file'
         for ext in pathexts:
             executable = pathcommand + ext
             if os.path.exists(executable):
                 return executable
         return None
 
     if os.sep in command:
         return findexisting(command)
 
     for path in os.environ.get('PATH', '').split(os.pathsep):
         executable = findexisting(os.path.join(path, command))
         if executable is not None:
             return executable
     return None
 
 def set_signal_handler():
     try:
         set_signal_handler_win32()
     except NameError:
         pass
 
 def statfiles(files):
     '''Stat each file in files and yield stat or None if file does not exist.
     Cluster and cache stat per directory to minimize number of OS stat calls.'''
     ncase = os.path.normcase
     sep   = os.sep
     dircache = {} # dirname -> filename -> status | None if file does not exist
     for nf in files:
         nf  = ncase(nf)
         pos = nf.rfind(sep)
         if pos == -1:
             dir, base = '.', nf
         else:
             dir, base = nf[:pos+1], nf[pos+1:]
         cache = dircache.get(dir, None)
         if cache is None:
             try:
                 dmap = dict([(ncase(n), s)
                     for n, k, s in osutil.listdir(dir, True)])
             except OSError, err:
                 # handle directory not found in Python version prior to 2.5
                 # Python <= 2.4 returns native Windows code 3 in errno
                 # Python >= 2.5 returns ENOENT and adds winerror field
                 # EINVAL is raised if dir is not a directory.
                 if err.errno not in (3, errno.ENOENT, errno.EINVAL,
                                      errno.ENOTDIR):
                     raise
                 dmap = {}
             cache = dircache.setdefault(dir, dmap)
         yield cache.get(base, None)
 
 def getuser():
     '''return name of current user'''
     raise error.Abort(_('user name not available - set USERNAME '
                        'environment variable'))
 
 def username(uid=None):
     """Return the name of the user with the given uid.
 
     If uid is None, return the name of the current user."""
     return None
 
 def groupname(gid=None):
     """Return the name of the group with the given gid.
 
     If gid is None, return the name of the current group."""
     return None
 
 def _removedirs(name):
     """special version of os.removedirs that does not remove symlinked
     directories or junction points if they actually contain files"""
     if osutil.listdir(name):
         return
     os.rmdir(name)
     head, tail = os.path.split(name)
     if not tail:
         head, tail = os.path.split(head)
     while head and tail:
         try:
             if osutil.listdir(name):
                 return
             os.rmdir(head)
         except:
             break
         head, tail = os.path.split(head)
 
 def unlink(f):
     """unlink and remove the directory if it is empty"""
     os.unlink(f)
     # try removing directories that might now be empty
     try:
         _removedirs(os.path.dirname(f))
     except OSError:
         pass
 
 try:
     # override functions with win32 versions if possible
     from win32 import *
 except ImportError:
     pass
 
 expandglobs = True

tests/test-trusted.py

@@ -1,189 +1,189 b''
 # Since it's not easy to write a test that portably deals
 # with files from different users/groups, we cheat a bit by
 # monkey-patching some functions in the util module
 
 import os
 from mercurial import ui, util, error
 
 hgrc = os.environ['HGRCPATH']
 f = open(hgrc)
 basehgrc = f.read()
 f.close()
 
 def testui(user='foo', group='bar', tusers=(), tgroups=(),
            cuser='foo', cgroup='bar', debug=False, silent=False):
     # user, group => owners of the file
     # tusers, tgroups => trusted users/groups
     # cuser, cgroup => user/group of the current process
 
     # write a global hgrc with the list of trusted users/groups and
     # some setting so that we can be sure it was read
     f = open(hgrc, 'w')
     f.write(basehgrc)
     f.write('\n[paths]\n')
     f.write('global = /some/path\n\n')
 
     if tusers or tgroups:
         f.write('[trusted]\n')
         if tusers:
             f.write('users = %s\n' % ', '.join(tusers))
         if tgroups:
             f.write('groups = %s\n' % ', '.join(tgroups))
     f.close()
 
     # override the functions that give names to uids and gids
     def username(uid=None):
         if uid is None:
             return cuser
         return user
     util.username = username
 
     def groupname(gid=None):
         if gid is None:
             return 'bar'
         return group
     util.groupname = groupname
 
-    def isowner(fp, st=None):
+    def isowner(st):
         return user == cuser
     util.isowner = isowner
 
     # try to read everything
     #print '# File belongs to user %s, group %s' % (user, group)
     #print '# trusted users = %s; trusted groups = %s' % (tusers, tgroups)
     kind = ('different', 'same')
     who = ('', 'user', 'group', 'user and the group')
     trusted = who[(user in tusers) + 2*(group in tgroups)]
     if trusted:
         trusted = ', but we trust the ' + trusted
     print '# %s user, %s group%s' % (kind[user == cuser], kind[group == cgroup],
                                      trusted)
 
     u = ui.ui()
     u.setconfig('ui', 'debug', str(bool(debug)))
     u.readconfig('.hg/hgrc')
     if silent:
         return u
     print 'trusted'
     for name, path in u.configitems('paths'):
         print '   ', name, '=', path
     print 'untrusted'
     for name, path in u.configitems('paths', untrusted=True):
         print '.',
         u.config('paths', name) # warning with debug=True
         print '.',
         u.config('paths', name, untrusted=True) # no warnings
         print name, '=', path
     print
 
     return u
 
 os.mkdir('repo')
 os.chdir('repo')
 os.mkdir('.hg')
 f = open('.hg/hgrc', 'w')
 f.write('[paths]\n')
 f.write('local = /another/path\n\n')
 f.close()
 
 #print '# Everything is run by user foo, group bar\n'
 
 # same user, same group
 testui()
 # same user, different group
 testui(group='def')
 # different user, same group
 testui(user='abc')
 # ... but we trust the group
 testui(user='abc', tgroups=['bar'])
 # different user, different group
 testui(user='abc', group='def')
 # ... but we trust the user
 testui(user='abc', group='def', tusers=['abc'])
 # ... but we trust the group
 testui(user='abc', group='def', tgroups=['def'])
 # ... but we trust the user and the group
 testui(user='abc', group='def', tusers=['abc'], tgroups=['def'])
 # ... but we trust all users
 print '# we trust all users'
 testui(user='abc', group='def', tusers=['*'])
 # ... but we trust all groups
 print '# we trust all groups'
 testui(user='abc', group='def', tgroups=['*'])
 # ... but we trust the whole universe
 print '# we trust all users and groups'
 testui(user='abc', group='def', tusers=['*'], tgroups=['*'])
 # ... check that users and groups are in different namespaces
 print "# we don't get confused by users and groups with the same name"
 testui(user='abc', group='def', tusers=['def'], tgroups=['abc'])
 # ... lists of user names work
 print "# list of user names"
 testui(user='abc', group='def', tusers=['foo', 'xyz', 'abc', 'bleh'],
        tgroups=['bar', 'baz', 'qux'])
 # ... lists of group names work
 print "# list of group names"
 testui(user='abc', group='def', tusers=['foo', 'xyz', 'bleh'],
        tgroups=['bar', 'def', 'baz', 'qux'])
 
 print "# Can't figure out the name of the user running this process"
 testui(user='abc', group='def', cuser=None)
 
 print "# prints debug warnings"
 u = testui(user='abc', group='def', cuser='foo', debug=True)
 
 print "# ui.readconfig sections"
 filename = 'foobar'
 f = open(filename, 'w')
 f.write('[foobar]\n')
 f.write('baz = quux\n')
 f.close()
 u.readconfig(filename, sections = ['foobar'])
 print u.config('foobar', 'baz')
 
 print
 print "# read trusted, untrusted, new ui, trusted"
 u = ui.ui()
 u.setconfig('ui', 'debug', 'on')
 u.readconfig(filename)
 u2 = u.copy()
 def username(uid=None):
     return 'foo'
 util.username = username
 u2.readconfig('.hg/hgrc')
 print 'trusted:'
 print u2.config('foobar', 'baz')
 print 'untrusted:'
 print u2.config('foobar', 'baz', untrusted=True)
 
 print
 print "# error handling"
 
 def assertraises(f, exc=util.Abort):
     try:
         f()
     except exc, inst:
         print 'raised', inst.__class__.__name__
     else:
         print 'no exception?!'
 
 print "# file doesn't exist"
 os.unlink('.hg/hgrc')
 assert not os.path.exists('.hg/hgrc')
 testui(debug=True, silent=True)
 testui(user='abc', group='def', debug=True, silent=True)
 
 print
 print "# parse error"
 f = open('.hg/hgrc', 'w')
 f.write('foo')
 f.close()
 
 try:
     testui(user='abc', group='def', silent=True)
 except error.ConfigError, inst:
     print inst
 
 try:
     testui(debug=True, silent=True)
 except error.ConfigError, inst:
     print inst