( )⚙ D10375 urlutil: extract `parseurl` from `hg` into the new module

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10375

urlutil: extract `parseurl` from `hg` into the new module
ClosedPublic

Authored by marmoute on Apr 12 2021, 11:30 AM.

Details

Reviewers
durin42
martinvonz
pulkit
Group Reviewers
hg-reviewers
Commits
rHG4452cb788404: urlutil: extract `parseurl` from `hg` into the new module
Summary

The new module is well fitting for this new code. And this will be useful to
make the gathered code collaborate more later.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 26828

hgext/histedit.py

def findoutgoing(ui, repo, remote=None, force=False, opts=None): def findoutgoing(ui, repo, remote=None, force=False, opts=None):
"""utility function to find the first outgoing changeset """utility function to find the first outgoing changeset
Used by initialization code""" Used by initialization code"""
if opts is None: if opts is None:
opts = {} opts = {}
dest = ui.expandpath(remote or b'default-push', remote or b'default') dest = ui.expandpath(remote or b'default-push', remote or b'default')
dest, branches = hg.parseurl(dest, None)[:2] dest, branches = urlutil.parseurl(dest, None)[:2]
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest))
revs, checkout = hg.addbranchrevs(repo, repo, branches, None) revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
other = hg.peer(repo, opts, dest) other = hg.peer(repo, opts, dest)
if revs: if revs:
revs = [repo.lookup(rev) for rev in revs] revs = [repo.lookup(rev) for rev in revs]

hgext/infinitepush/__init__.py

from mercurial.pycompat import ( from mercurial.pycompat import (
getattr, getattr,
open, open,
) )
from mercurial.utils import ( from mercurial.utils import (
procutil, procutil,
stringutil, stringutil,
urlutil,
) )
from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
commands, commands,
discovery, discovery,
encoding, encoding,
return b"%d %s\n" % (0, r) return b"%d %s\n" % (0, r)
return _lookup return _lookup
def _pull(orig, ui, repo, source=b"default", **opts): def _pull(orig, ui, repo, source=b"default", **opts):
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
# Copy paste from `pull` command # Copy paste from `pull` command
source, branches = hg.parseurl(ui.expandpath(source), opts.get(b'branch')) source, branches = urlutil.parseurl(
ui.expandpath(source), opts.get(b'branch')
)
scratchbookmarks = {} scratchbookmarks = {}
unfi = repo.unfiltered() unfi = repo.unfiltered()
unknownnodes = [] unknownnodes = []
for rev in opts.get(b'rev', []): for rev in opts.get(b'rev', []):
if rev not in unfi: if rev not in unfi:
unknownnodes.append(rev) unknownnodes.append(rev)
if opts.get(b'bookmark'): if opts.get(b'bookmark'):

hgext/largefiles/storefactory.py

else: else:
path = ui.expandpath(b'default') path = ui.expandpath(b'default')
# ui.expandpath() leaves 'default-push' and 'default' alone if # ui.expandpath() leaves 'default-push' and 'default' alone if
# they cannot be expanded: fallback to the empty string, # they cannot be expanded: fallback to the empty string,
# meaning the current directory. # meaning the current directory.
if repo is None: if repo is None:
path = ui.expandpath(b'default') path = ui.expandpath(b'default')
path, _branches = hg.parseurl(path) path, _branches = urlutil.parseurl(path)
remote = hg.peer(repo or ui, {}, path) remote = hg.peer(repo or ui, {}, path)
elif path == b'default-push' or path == b'default': elif path == b'default-push' or path == b'default':
remote = repo remote = repo
else: else:
path, _branches = hg.parseurl(path) path, _branches = urlutil.parseurl(path)
remote = hg.peer(repo or ui, {}, path) remote = hg.peer(repo or ui, {}, path)
# The path could be a scheme so use Mercurial's normal functionality # The path could be a scheme so use Mercurial's normal functionality
# to resolve the scheme to a repository and use its path # to resolve the scheme to a repository and use its path
path = util.safehasattr(remote, b'url') and remote.url() or remote.path path = util.safehasattr(remote, b'url') and remote.url() or remote.path
match = _scheme_re.match(path) match = _scheme_re.match(path)
if not match: # regular filesystem path if not match: # regular filesystem path

hgext/narrow/narrowcommands.py

with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
# Find the revisions we have in common with the remote. These will # Find the revisions we have in common with the remote. These will
# be used for finding local-only changes for narrowing. They will # be used for finding local-only changes for narrowing. They will
# also define the set of revisions to update for widening. # also define the set of revisions to update for widening.
remotepath = ui.expandpath(remotepath or b'default') remotepath = ui.expandpath(remotepath or b'default')
url, branches = hg.parseurl(remotepath) url, branches = urlutil.parseurl(remotepath)
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(url)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(url))
remote = hg.peer(repo, opts, url) remote = hg.peer(repo, opts, url)
try: try:
# check narrow support before doing anything if widening needs to be # check narrow support before doing anything if widening needs to be
# performed. In future we should also abort if client is ellipses and # performed. In future we should also abort if client is ellipses and
# server does not support ellipses # server does not support ellipses
if ( if (

hgext/patchbomb.py

return msgs return msgs
def _getoutgoing(repo, dest, revs): def _getoutgoing(repo, dest, revs):
'''Return the revisions present locally but not in dest''' '''Return the revisions present locally but not in dest'''
ui = repo.ui ui = repo.ui
url = ui.expandpath(dest or b'default-push', dest or b'default') url = ui.expandpath(dest or b'default-push', dest or b'default')
url = hg.parseurl(url)[0] url = urlutil.parseurl(url)[0]
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(url)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(url))
revs = [r for r in revs if r >= 0] revs = [r for r in revs if r >= 0]
if not revs: if not revs:
revs = [repo.changelog.tiprev()] revs = [repo.changelog.tiprev()]
revs = repo.revs(b'outgoing(%s) and ::%ld', dest or b'', revs) revs = repo.revs(b'outgoing(%s) and ::%ld', dest or b'', revs)
if not revs: if not revs:
ui.status(_(b"no changes found\n")) ui.status(_(b"no changes found\n"))

mercurial/commands.py

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
raise error.InputError( raise error.InputError(
_(b"--base is incompatible with specifying a destination") _(b"--base is incompatible with specifying a destination")
) )
common = [repo[rev].node() for rev in base] common = [repo[rev].node() for rev in base]
heads = [repo[r].node() for r in revs] if revs else None heads = [repo[r].node() for r in revs] if revs else None
outgoing = discovery.outgoing(repo, common, heads) outgoing = discovery.outgoing(repo, common, heads)
else: else:
dest = ui.expandpath(dest or b'default-push', dest or b'default') dest = ui.expandpath(dest or b'default-push', dest or b'default')
dest, branches = hg.parseurl(dest, opts.get(b'branch')) dest, branches = urlutil.parseurl(dest, opts.get(b'branch'))
other = hg.peer(repo, opts, dest) other = hg.peer(repo, opts, dest)
revs = [repo[r].hex() for r in revs] revs = [repo[r].hex() for r in revs]
revs, checkout = hg.addbranchrevs(repo, repo, branches, revs) revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
heads = revs and pycompat.maplist(repo.lookup, revs) or revs heads = revs and pycompat.maplist(repo.lookup, revs) or revs
outgoing = discovery.findcommonoutgoing( outgoing = discovery.findcommonoutgoing(
repo, repo,
other, other,
onlyheads=heads, onlyheads=heads,
default = not (num or id or branch or tags or bookmarks) default = not (num or id or branch or tags or bookmarks)
output = [] output = []
revs = [] revs = []
peer = None peer = None
try: try:
if source: if source:
source, branches = hg.parseurl(ui.expandpath(source)) source, branches = urlutil.parseurl(ui.expandpath(source))
# only pass ui when no repo # only pass ui when no repo
peer = hg.peer(repo or ui, opts, source) peer = hg.peer(repo or ui, opts, source)
repo = peer.local() repo = peer.local()
revs, checkout = hg.addbranchrevs(repo, peer, branches, None) revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
fm = ui.formatter(b'identify', opts) fm = ui.formatter(b'identify', opts)
fm.startitem() fm.startitem()
) )
hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True) hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
return 0 return 0
cmdutil.check_incompatible_arguments(opts, b'subrepos', [b'bundle']) cmdutil.check_incompatible_arguments(opts, b'subrepos', [b'bundle'])
if opts.get(b'bookmarks'): if opts.get(b'bookmarks'):
source, branches = hg.parseurl( source, branches = urlutil.parseurl(
ui.expandpath(source), opts.get(b'branch') ui.expandpath(source), opts.get(b'branch')
) )
other = hg.peer(repo, opts, source) other = hg.peer(repo, opts, source)
try: try:
if b'bookmarks' not in other.listkeys(b'namespaces'): if b'bookmarks' not in other.listkeys(b'namespaces'):
ui.warn(_(b"remote doesn't support bookmarks\n")) ui.warn(_(b"remote doesn't support bookmarks\n"))
return 0 return 0
ui.pager(b'incoming') ui.pager(b'incoming')
): ):
msg = _(b'update destination required by configuration') msg = _(b'update destination required by configuration')
hint = _(b'use hg pull followed by hg update DEST') hint = _(b'use hg pull followed by hg update DEST')
raise error.InputError(msg, hint=hint) raise error.InputError(msg, hint=hint)
if not sources: if not sources:
sources = [b'default'] sources = [b'default']
for source in sources: for source in sources:
source, branches = hg.parseurl( source, branches = urlutil.parseurl(
ui.expandpath(source), opts.get(b'branch') ui.expandpath(source), opts.get(b'branch')
) )
ui.status(_(b'pulling from %s\n') % urlutil.hidepassword(source)) ui.status(_(b'pulling from %s\n') % urlutil.hidepassword(source))
ui.flush() ui.flush()
other = hg.peer(repo, opts, source) other = hg.peer(repo, opts, source)
update_conflict = None update_conflict = None
try: try:
revs, checkout = hg.addbranchrevs( revs, checkout = hg.addbranchrevs(
if i: if i:
needsincoming = True needsincoming = True
if o: if o:
needsoutgoing = True needsoutgoing = True
if not needsincoming and not needsoutgoing: if not needsincoming and not needsoutgoing:
return return
def getincoming(): def getincoming():
source, branches = hg.parseurl(ui.expandpath(b'default')) source, branches = urlutil.parseurl(ui.expandpath(b'default'))
sbranch = branches[0] sbranch = branches[0]
try: try:
other = hg.peer(repo, {}, source) other = hg.peer(repo, {}, source)
except error.RepoError: except error.RepoError:
if opts.get(b'remote'): if opts.get(b'remote'):
raise raise
return source, sbranch, None, None, None return source, sbranch, None, None, None
revs, checkout = hg.addbranchrevs(repo, other, branches, None) revs, checkout = hg.addbranchrevs(repo, other, branches, None)
if revs: if revs:
revs = [other.lookup(rev) for rev in revs] revs = [other.lookup(rev) for rev in revs]
ui.debug(b'comparing with %s\n' % urlutil.hidepassword(source)) ui.debug(b'comparing with %s\n' % urlutil.hidepassword(source))
repo.ui.pushbuffer() repo.ui.pushbuffer()
commoninc = discovery.findcommonincoming(repo, other, heads=revs) commoninc = discovery.findcommonincoming(repo, other, heads=revs)
repo.ui.popbuffer() repo.ui.popbuffer()
return source, sbranch, other, commoninc, commoninc[1] return source, sbranch, other, commoninc, commoninc[1]
if needsincoming: if needsincoming:
source, sbranch, sother, commoninc, incoming = getincoming() source, sbranch, sother, commoninc, incoming = getincoming()
else: else:
source = sbranch = sother = commoninc = incoming = None source = sbranch = sother = commoninc = incoming = None
def getoutgoing(): def getoutgoing():
dest, branches = hg.parseurl(ui.expandpath(b'default-push', b'default')) dest, branches = urlutil.parseurl(
ui.expandpath(b'default-push', b'default')
)
dbranch = branches[0] dbranch = branches[0]
revs, checkout = hg.addbranchrevs(repo, repo, branches, None) revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
if source != dest: if source != dest:
try: try:
dother = hg.peer(repo, {}, dest) dother = hg.peer(repo, {}, dest)
except error.RepoError: except error.RepoError:
if opts.get(b'remote'): if opts.get(b'remote'):
raise raise

mercurial/debugcommands.py

local_revs = opts[b"local_as_revs"] local_revs = opts[b"local_as_revs"]
remote_revs = opts[b"remote_as_revs"] remote_revs = opts[b"remote_as_revs"]
# make sure tests are repeatable # make sure tests are repeatable
random.seed(int(opts[b'seed'])) random.seed(int(opts[b'seed']))
if not remote_revs: if not remote_revs:
remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl)) remoteurl, branches = urlutil.parseurl(ui.expandpath(remoteurl))
remote = hg.peer(repo, opts, remoteurl) remote = hg.peer(repo, opts, remoteurl)
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl))
else: else:
branches = (None, []) branches = (None, [])
remote_filtered_revs = scmutil.revrange( remote_filtered_revs = scmutil.revrange(
unfi, [b"not (::(%s))" % remote_revs] unfi, [b"not (::(%s))" % remote_revs]
) )
remote_filtered_revs = frozenset(remote_filtered_revs) remote_filtered_revs = frozenset(remote_filtered_revs)
raise error.Abort( raise error.Abort(
_( _(
b"there is no Mercurial repository here, and no " b"there is no Mercurial repository here, and no "
b"server specified" b"server specified"
) )
) )
source = b"default" source = b"default"
source, branches = hg.parseurl(ui.expandpath(source)) source, branches = urlutil.parseurl(ui.expandpath(source))
url = urlutil.url(source) url = urlutil.url(source)
defaultport = {b'https': 443, b'ssh': 22} defaultport = {b'https': 443, b'ssh': 22}
if url.scheme in defaultport: if url.scheme in defaultport:
try: try:
addr = (url.host, int(url.port or defaultport[url.scheme])) addr = (url.host, int(url.port or defaultport[url.scheme]))
except ValueError: except ValueError:
raise error.Abort(_(b"malformed port number in URL")) raise error.Abort(_(b"malformed port number in URL"))
ui.status(msg, label=b"status.removed") ui.status(msg, label=b"status.removed")
else: else:
ui.status(_(b"no backup changesets found\n")) ui.status(_(b"no backup changesets found\n"))
return return
for backup in backups: for backup in backups:
# Much of this is copied from the hg incoming logic # Much of this is copied from the hg incoming logic
source = ui.expandpath(os.path.relpath(backup, encoding.getcwd())) source = ui.expandpath(os.path.relpath(backup, encoding.getcwd()))
source, branches = hg.parseurl(source, opts.get(b"branch")) source, branches = urlutil.parseurl(source, opts.get(b"branch"))
try: try:
other = hg.peer(repo, opts, source) other = hg.peer(repo, opts, source)
except error.LookupError as ex: except error.LookupError as ex:
msg = _(b"\nwarning: unable to open bundle %s") % source msg = _(b"\nwarning: unable to open bundle %s") % source
hint = _(b"\n(missing parent rev %s)\n") % short(ex.name) hint = _(b"\n(missing parent rev %s)\n") % short(ex.name)
ui.warn(msg, hint=hint) ui.warn(msg, hint=hint)
continue continue
revs, checkout = hg.addbranchrevs( revs, checkout = hg.addbranchrevs(

mercurial/hg.py

if hashbranch: if hashbranch:
if not primary(hashbranch): if not primary(hashbranch):
revs.append(hashbranch) revs.append(hashbranch)
return revs, revs[0] return revs, revs[0]
def parseurl(path, branches=None): def parseurl(path, branches=None):
'''parse url#branch, returning (url, (branch, branches))''' '''parse url#branch, returning (url, (branch, branches))'''
msg = b'parseurl(...) moved to mercurial.utils.urlutil'
u = urlutil.url(path) util.nouideprecwarn(msg, b'6.0', stacklevel=2)
branch = None return urlutil.parseurl(path, branches=branches)
if u.fragment:
branch = u.fragment
u.fragment = None
return bytes(u), (branch, branches or [])
schemes = { schemes = {
b'bundle': bundlerepo, b'bundle': bundlerepo,
b'union': unionrepo, b'union': unionrepo,
b'file': _local, b'file': _local,
b'http': httppeer, b'http': httppeer,
b'https': httppeer, b'https': httppeer,
if repo.sharedpath == repo.path: if repo.sharedpath == repo.path:
return None return None
if util.safehasattr(repo, b'srcrepo') and repo.srcrepo: if util.safehasattr(repo, b'srcrepo') and repo.srcrepo:
return repo.srcrepo return repo.srcrepo
# the sharedpath always ends in the .hg; we want the path to the repo # the sharedpath always ends in the .hg; we want the path to the repo
source = repo.vfs.split(repo.sharedpath)[0] source = repo.vfs.split(repo.sharedpath)[0]
srcurl, branches = parseurl(source) srcurl, branches = urlutil.parseurl(source)
srcrepo = repository(repo.ui, srcurl) srcrepo = repository(repo.ui, srcurl)
repo.srcrepo = srcrepo repo.srcrepo = srcrepo
return srcrepo return srcrepo
def share( def share(
ui, ui,
source, source,
if not dest: if not dest:
dest = defaultdest(source) dest = defaultdest(source)
else: else:
dest = ui.expandpath(dest) dest = ui.expandpath(dest)
if isinstance(source, bytes): if isinstance(source, bytes):
origsource = ui.expandpath(source) origsource = ui.expandpath(source)
source, branches = parseurl(origsource) source, branches = urlutil.parseurl(origsource)
srcrepo = repository(ui, source) srcrepo = repository(ui, source)
rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None)
else: else:
srcrepo = source.local() srcrepo = source.local()
checkout = None checkout = None
shareditems = set() shareditems = set()
if bookmarks: if bookmarks:
will be included (a "full" clone). Otherwise a "narrow" clone containing will be included (a "full" clone). Otherwise a "narrow" clone containing
only the requested files will be performed. If ``storeincludepats`` is not only the requested files will be performed. If ``storeincludepats`` is not
defined but ``storeexcludepats`` is, ``storeincludepats`` is assumed to be defined but ``storeexcludepats`` is, ``storeincludepats`` is assumed to be
``path:.``. If both are empty sets, no files will be cloned. ``path:.``. If both are empty sets, no files will be cloned.
""" """
if isinstance(source, bytes): if isinstance(source, bytes):
origsource = ui.expandpath(source) origsource = ui.expandpath(source)
source, branches = parseurl(origsource, branch) source, branches = urlutil.parseurl(origsource, branch)
srcpeer = peer(ui, peeropts, source) srcpeer = peer(ui, peeropts, source)
else: else:
srcpeer = source.peer() # in case we were called with a localrepo srcpeer = source.peer() # in case we were called with a localrepo
branches = (None, branch or []) branches = (None, branch or [])
origsource = source = srcpeer.url() origsource = source = srcpeer.url()
srclock = destlock = cleandir = None srclock = destlock = cleandir = None
destpeer = None destpeer = None
try: try:
displaychlist, subreporecurse, ui, repo, source, opts, buffered=False displaychlist, subreporecurse, ui, repo, source, opts, buffered=False
): ):
""" """
Helper for incoming / gincoming. Helper for incoming / gincoming.
displaychlist gets called with displaychlist gets called with
(remoterepo, incomingchangesetlist, displayer) parameters, (remoterepo, incomingchangesetlist, displayer) parameters,
and is supposed to contain only code that can't be unified. and is supposed to contain only code that can't be unified.
""" """
source, branches = parseurl(ui.expandpath(source), opts.get(b'branch')) source, branches = urlutil.parseurl(
ui.expandpath(source), opts.get(b'branch')
)
other = peer(repo, opts, source) other = peer(repo, opts, source)
cleanupfn = other.close cleanupfn = other.close
try: try:
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(source)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(source))
revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev')) revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev'))
if revs: if revs:
revs = [other.lookup(rev) for rev in revs] revs = [other.lookup(rev) for rev in revs]

mercurial/revset.py

scmutil, scmutil,
smartset, smartset,
stack as stackmod, stack as stackmod,
util, util,
) )
from .utils import ( from .utils import (
dateutil, dateutil,
stringutil, stringutil,
urlutil,
) )
# helpers for processing parsed tree # helpers for processing parsed tree
getsymbol = revsetlang.getsymbol getsymbol = revsetlang.getsymbol
getstring = revsetlang.getstring getstring = revsetlang.getstring
getinteger = revsetlang.getinteger getinteger = revsetlang.getinteger
getboolean = revsetlang.getboolean getboolean = revsetlang.getboolean
getlist = revsetlang.getlist getlist = revsetlang.getlist
if q == b'.': if q == b'.':
q = repo[b'.'].branch() q = repo[b'.'].branch()
dest = b'' dest = b''
if len(l) > 1: if len(l) > 1:
# i18n: "remote" is a keyword # i18n: "remote" is a keyword
dest = getstring(l[1], _(b"remote requires a repository path")) dest = getstring(l[1], _(b"remote requires a repository path"))
dest = repo.ui.expandpath(dest or b'default') dest = repo.ui.expandpath(dest or b'default')
dest, branches = hg.parseurl(dest) dest, branches = urlutil.parseurl(dest)
other = hg.peer(repo, {}, dest) other = hg.peer(repo, {}, dest)
n = other.lookup(q) n = other.lookup(q)
if n in repo: if n in repo:
r = repo[n].rev() r = repo[n].rev()
if r in subset: if r in subset:
return baseset([r]) return baseset([r])
return baseset() return baseset()

mercurial/utils/urlutil.py

def removeauth(u): def removeauth(u):
# type: (bytes) -> bytes # type: (bytes) -> bytes
'''remove all authentication information from a url string''' '''remove all authentication information from a url string'''
u = url(u) u = url(u)
u.user = u.passwd = None u.user = u.passwd = None
return bytes(u) return bytes(u)
def parseurl(path, branches=None):
'''parse url#branch, returning (url, (branch, branches))'''
u = url(path)
branch = None
if u.fragment:
branch = u.fragment
u.fragment = None
return bytes(u), (branch, branches or [])
class paths(dict): class paths(dict):
"""Represents a collection of paths and their configs. """Represents a collection of paths and their configs.
Data is initially derived from ui instances and the config files they have Data is initially derived from ui instances and the config files they have
loaded. loaded.
""" """
def __init__(self, ui): def __init__(self, ui):

tests/test-hg-parseurl.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import unittest import unittest
from mercurial import hg from mercurial.utils import urlutil
class ParseRequestTests(unittest.TestCase): class ParseRequestTests(unittest.TestCase):
def testparse(self): def testparse(self):
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com/no/anchor'), urlutil.parseurl(b'http://example.com/no/anchor'),
(b'http://example.com/no/anchor', (None, [])), (b'http://example.com/no/anchor', (None, [])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com/an/anchor#foo'), urlutil.parseurl(b'http://example.com/an/anchor#foo'),
(b'http://example.com/an/anchor', (b'foo', [])), (b'http://example.com/an/anchor', (b'foo', [])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com/no/anchor/branches', [b'foo']), urlutil.parseurl(
b'http://example.com/no/anchor/branches', [b'foo']
),
(b'http://example.com/no/anchor/branches', (None, [b'foo'])), (b'http://example.com/no/anchor/branches', (None, [b'foo'])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com/an/anchor/branches#bar', [b'foo']), urlutil.parseurl(
b'http://example.com/an/anchor/branches#bar', [b'foo']
),
(b'http://example.com/an/anchor/branches', (b'bar', [b'foo'])), (b'http://example.com/an/anchor/branches', (b'bar', [b'foo'])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl( urlutil.parseurl(
b'http://example.com/an/anchor/branches-None#foo', None b'http://example.com/an/anchor/branches-None#foo', None
), ),
(b'http://example.com/an/anchor/branches-None', (b'foo', [])), (b'http://example.com/an/anchor/branches-None', (b'foo', [])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com/'), urlutil.parseurl(b'http://example.com/'),
(b'http://example.com/', (None, [])), (b'http://example.com/', (None, [])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com'), urlutil.parseurl(b'http://example.com'),
(b'http://example.com/', (None, [])), (b'http://example.com/', (None, [])),
) )
self.assertEqual( self.assertEqual(
hg.parseurl(b'http://example.com#foo'), urlutil.parseurl(b'http://example.com#foo'),
(b'http://example.com/', (b'foo', [])), (b'http://example.com/', (b'foo', [])),
) )
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)