o

�]LbAw�@s�
dd
lZdd
l
Zdd
lZddlmZ
ddlmZmZ
ddl	m
Z
mZmZmZ
ddl	m
Z

ejr5ddlmZ
ejZd	d
�ZGdd�de�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�ZdBdd�
Zdd�Zdd�Zdd �ZdBd!d"�
ZdCd$d%�
Z dDd&d'�
Z!dBd(d)�
Z"Gd*d+�d+e#�Z$iZ%d,d-�Z&e&d.d/�d0d1��
Z'e&d2d2�d3d4��
Z(hd5�
Z)e&d6d7�d8d9��
Z*e&d:d;�d<d=��
Z+d>d?�Z,Gd@dA�dAe�Z-d
S)E�N�)
�
_)�getattr�setattr)�encoding�error�pycompat�urllibcompat�
)
�
stringutil)
�Unionc

CsTzt|�
WSt
y


Yn
wz	t�t�|�
�
WStjy)


t�td
�
|�
�
w)z�Return the port for a given network service.

    If port is an integer, it's returned as is. If it's a string, it's
    looked up using socket.getservbyname(). If there's no matching
    service, error.Abort is raised.
    s+no port number associated with service '%s')	�int�
ValueError�socket�
getservbynamer�sysstrr�Abortr)
�port�r�9/usr/lib/python3/dist-packages/mercurial/utils/urlutil.py�getport$s



�




��rc@sveZ
dZd
ZdZdZe�d�
jZ	ddd�
Z
dd	�Zej
d
d��
Zdd
�Ze�
e�
Zdd�Zdd�Zdd�Zdd�ZdS)�urla�	Reliable URL parser.

    This parses URLs and provides attributes for the following
    components:

    <scheme>://<user>:<passwd>@<host>:<port>/<path>?<query>#<fragment>

    Missing components are set to None. The only exception is
    fragment, which is set to '' if present but empty.

    If parsefragment is False, fragment is included in query. If
    parsequery is False, query is included in path. If both are
    False, both fragment and query are included in path.

    See http://www.ietf.org/rfc/rfc2396.txt for more information.

    Note that for backward compatibility reasons, bundle URLs do not
    take host names. That means 'bundle://../' has a path of '../'.

    Examples:

    >>> url(b'http://www.ietf.org/rfc/rfc2396.txt')
    <url scheme: 'http', host: 'www.ietf.org', path: 'rfc/rfc2396.txt'>
    >>> url(b'ssh://[::1]:2200//home/joe/repo')
    <url scheme: 'ssh', host: '[::1]', port: '2200', path: '/home/joe/repo'>
    >>> url(b'file:///home/joe/repo')
    <url scheme: 'file', path: '/home/joe/repo'>
    >>> url(b'file:///c:/temp/foo/')
    <url scheme: 'file', path: 'c:/temp/foo/'>
    >>> url(b'bundle:foo')
    <url scheme: 'bundle', path: 'foo'>
    >>> url(b'bundle://../foo')
    <url scheme: 'bundle', path: '../foo'>
    >>> url(br'c:\foo\bar')
    <url path: 'c:\\foo\\bar'>
    >>> url(br'\\blah\blah\blah')
    <url path: '\\\\blah\\blah\\blah'>
    >>> url(br'\\blah\blah\blah#baz')
    <url path: '\\\\blah\\blah\\blah', fragment: 'baz'>
    >>> url(br'file:///C:\users\me')
    <url scheme: 'file', path: 'C:\\users\\me'>

    Authentication credentials:

    >>> url(b'ssh://joe:xyz@x/repo')
    <url scheme: 'ssh', user: 'joe', passwd: 'xyz', host: 'x', path: 'repo'>
    >>> url(b'ssh://joe@x/repo')
    <url scheme: 'ssh', user: 'joe', host: 'x', path: 'repo'>

    Query strings and fragments:

    >>> url(b'http://host/a?b#c')
    <url scheme: 'http', host: 'host', path: 'a', query: 'b', fragment: 'c'>
    >>> url(b'http://host/a?b#c', parsequery=False, parsefragment=False)
    <url scheme: 'http', host: 'host', path: 'a?b#c'>

    Empty path:

    >>> url(b'')
    <url path: ''>
    >>> url(b'#a')
    <url path: '', fragment: 'a'>
    >>> url(b'http://host/')
    <url scheme: 'http', host: 'host', path: ''>
    >>> url(b'http://host/#a')
    <url scheme: 'http', host: 'host', path: '', fragment: 'a'>

    Only scheme:

    >>> url(b'http:')
    <url scheme: 'http'>
    s!~*'()+s
/!~*'()+:\s^[a-zA-Z0-9+.\-]+:TcCs�d|_|_
|_|_d|_|_|_|_d
|_d|_	|
|_
|r0d|
vr0|
�dd�\}
|_t|
�
s9|
�
d�
r>|
|_dS|
�
d�
r\d|_|
dd�}
|
�
d	�
rW|
d
d�}
|
|_dS|�|
�
rs|
�dd�}|drs|\|_}
d
|_|
s�d}
|jrd|_dSn�|jr�|
|_dS|r�d|
vr�|
�dd�\}
|_|
s�d}
|js�d|_|
r�|
�
d	�
r�|
d
d��dd�}t|�
dkr�|\|_}
n|d|_d}
|js�d|_|
r�t|
�
s�d|
}
|jr�d|jvr�|j�dd�\|_
|_d|j
vr�|j
�dd�\|_
|_|js�d|_|j�
r,d|jv�
r,|j�
d�
�
r|j�d�
�
s,|j|_	|j�dd�\|_|_|j�
s,d|_|j�
rC|jdk�
rC|jdv
�
rCt�td�
�
�
|
|_dD]}t||�}|du
�
r]t||t�|�
�
�
qHdS)NT��
#r
�\\�bundle:�bundle��//r�
:r
F�
?�
/�
@�
[�
]�file)s	localhosts	127.0.0.1s[::1]s(file:// URLs can only refer to localhost)�user�passwd�host�port�path�fragment)�scheme�user�passwd�hostr�path�query�fragment�
_localpath�	_hostport�	_origpath�split�hasdriveletter�
startswith�_matchscheme�len�rsplit�endswithrrrrr�urlreq�unquote)�selfr0�
parsequery�
parsefragment�parts�
a�
vrrr�__init__�s�
























�




















�
�
�


�

�




��zurl.__init__c
Csdtd
�
}
|j
|
_
|j|
_|j|
_|j|
_|j|
_|j
|
_
|j|
_|j|
_|j|
_|j	|
_	|j
|
_
|
S)Nstemporary useless value)rr0r,r-r.r/r1r2r3r4r5)r?�
urrr�copy�s












zurl.copyc
CsFg}
d
D]}t||�}|du
r|
�
d|t�|�
f�

qdd�|
�
S)N)sschemer&r'r(r)r*squeryr+s%s: %rs<url %s>s, )r�appendr�bytestr�join)r?�attrsrCrDrrr�__repr__�s




�
zurl.__repr__c
Cs�
|jr|j
}
|jd
krd|
}
|jr|
d|j7}
|
S|jd}
|js)|js)|jr.|
d7}
n|jrL|j
r?|j
�d�
s?t|j
�
rL|
d7}
t|j
�
rL|
d7}
|jrZ|
t	j
|j|jd�7}
|jrj|
dt	j
|j|jd�7}
|jsp|jrt|
d7}
|jr�|j�d	�
r�|j�d
�
s�|
t	�
|j�
7}
n|
|j7}
|j
r�|
dt	�
|j
�
7}
|jr�|
d7}
|j
r�|
t	j
|j
|jd�7}
|jr�|
d|j7}
|jdu
r�|
dt	j
|j|jd�7}
|
S)
a�Join the URL's components back into a URL string.

        Examples:

        >>> bytes(url(b'http://user:pw@host:80/c:/bob?fo:oo#ba:ar'))
        'http://user:pw@host:80/c:/bob?fo:oo#ba:ar'
        >>> bytes(url(b'http://user:pw@host:80/?foo=bar&baz=42'))
        'http://user:pw@host:80/?foo=bar&baz=42'
        >>> bytes(url(b'http://user:pw@host:80/?foo=bar%3dbaz'))
        'http://user:pw@host:80/?foo=bar%3dbaz'
        >>> bytes(url(b'ssh://user:pw@[::1]:2200//home/joe#'))
        'ssh://user:pw@[::1]:2200//home/joe#'
        >>> bytes(url(b'http://localhost:80//'))
        'http://localhost:80//'
        >>> bytes(url(b'http://localhost:80/'))
        'http://localhost:80/'
        >>> bytes(url(b'http://localhost:80'))
        'http://localhost:80/'
        >>> bytes(url(b'bundle:foo'))
        'bundle:foo'
        >>> bytes(url(b'bundle://../foo'))
        'bundle:../foo'
        >>> bytes(url(b'path'))
        'path'
        >>> bytes(url(b'file:///tmp/foo/bar'))
        'file:///tmp/foo/bar'
        >>> bytes(url(b'file:///c:/tmp/foo/bar'))
        'file:///c:/tmp/foo/bar'
        >>> print(url(br'bundle:foo\bar'))
        bundle:foo\bar
        >>> print(url(br'file:///D:\data\hg'))
        file:///D:\data\hg
        rrrrrr!)
�safer"r#r$r N)r3r0r,r2r-r.r/r8r7r=�quote�
_safecharsr<r�_safepcharsr1)r?�
srrr�	__bytes__
sR"












�
��






















z
url.__bytes__c
	Csr|j|j
}
}zd
\|_|_
t|�
}W|
||_|_
n|
||_|_
w|js*|dfS|d||jf|j|j
p6dffS)N)NNr)r-r.�bytesr/)r?r-r.rQrrr�authinfo`
s




 

zurl.authinfoc

CsF|jr
|jd
kr
dSt
|j�
rdS|j�d�
rdS|j�d�
r!dSdS)Nr%Trr!F)r,r7r0r8�
r?rrr�isabso
s









z	url.isabsc
Csf|jd
ks
|jdkr0|j
pd}
t|j�
r|jd|j
}
|
S|jdu
r.|j
r.t|
�
s.d|
}
|
S|jS)Nr%rr!)r,r0r7r4r/r5�r?r0rrr�	localpathz
s



�

z
url.localpathc

Cs|jp
|jd
kp
|jdkS)z?whether localpath will return something that posixfile can openr%r)
r,rUrrr�islocal�
s

��zurl.islocalN)TT)�__name__�
__module__�__qualname__�__doc__rOrP�remod�compile�matchr9rErGr�	strmethodrLrR�__str__rTrVrXrYrrrrr9s
I


f


Prc

Cstt
|�
j�
S�
N)�boolrr,�
r0rrr�	hasscheme�
srfc

Cs(t|�
o|d
d�dko|dd
��
�S)Nr
rrr
)rd�isalpharerrrr7�
s(r7c

Cst|d
d
d��
�S)NF)r@rA)rrXrerrr�urllocalpath�
srhc

Cs<t�
|�
}|�d
�
s|�d�
rt�td�
t�|�
f
�
�
dS)a\
check if a path / url is a potentially unsafe ssh exploit (SEC)

    This is a sanity check for ssh urls. ssh will parse the first item as
    an option; e.g. ssh://-oProxyCommand=curl${IFS}bad.server|sh/path.
    Let's prevent these potentially exploited urls entirely and warn the
    user.

    Raises an error.Abort when the url is unsafe.
    sssh://-ssvn+ssh://-spotentially unsafe url: %rN)r=r>r8rrrrrIrerrr�checksafessh�
s



��ric

Cst|�
}|j
r
d
|_
t|�
S)z$hide user credential in a url strings***)rr.rS�
rFrrr�hidepassword�
s


rkc

Cst|�
}d
|_
|_t|�
S)z7remove all authentication information from a url stringN)rr-r.rSrjrrr�
removeauth�
s

rlcCshg}|
d
ur!tt
�|j�
�
D]\}}|D]	}|�||f�

qq|S|j�|
g�D]	}|�|
|f�

q(|S)z+list all the (name, paths) in the passed uiN)�sortedr�	iteritems�pathsrH�get)�ui�target_path�result�namero�
pr0rrr�
list_paths�
s



��

rvcCs&zt|d
|
d�WSt
y


Yd
Sw)zLtry to build a path from a url

    Return None if no Path could built.
    N�
�rawloc)r0r)rqrrrr�try_path�
s


�ryccs��|s2d
|
jvr|
jd
D]}|V
q
dSd|
jvr'|
jdD]}|V
qdSt
jtd�
td�
d��
|D],}||
jvrG|
j|D]}|V
q@q4t|
|�}|dur]td�
}||;}t
�|�
�
|V
q4dS)z=yields all the `path` selected as push destination by `dests`sdefault-push�defaults"default repository not configured!ssee 'hg help config.paths')
�hintN�repository %s does not exist)ror�ConfigErrorrry�	RepoError)�reporq�destsru�destr0�msgrrr�get_push_paths�
s4�



�


�

�



�






�r�ccsR�|sd
g
}|D]}||
jvr|
j|D]}|V
qqt
|
d|dd�}|V
qdS)zDyields all the `(path, branch)` selected as pull source by `sources`rzNF)
�
validate_path)ror0)rrq�sources�sourcerurrr�get_pull_paths�
s�





�
�r�cCs~|d
urg}n|g
}tt
|
||��
}t|�
dkr;|d
ur)td�
}|t|�
|f;}n
td�
}|t|�
||f;}t�|�
�
|dS)a5
return a unique `path` or abort if multiple are found

    This is useful for command and action that does not support multiple
    destination (yet).

    Note that for now, we cannot get multiple destination so this function is "trivial".

    The `action` parameter will be used for the error message.
    Nr
�9default path points to %d urls while %s only supports one�5path points to %d urls while %s only supports one: %sr
)�listr�r:rrr)�actionrrqr�r�r�rrr�get_unique_push_paths






�



r�rcCs�g}|d
urd|jvr|�
dd�|jdD�
�

n.|�d�

n(||jvr2|�
dd�|j|D�
�

nt||�}|d
u
rB|�|j�

n|�|�

t|�
dkrp|d
ur^td�
}|t|�
|f;}n
td�
}|t|�
||f;}t�|�
�
t	|d	|�S)
a?
return a unique `(path, branch)` or abort if multiple are found

    This is useful for command and action that does not support multiple
    destination (yet).

    Note that for now, we cannot get multiple destination so this function is "trivial".

    The `action` parameter will be used for the error message.
    Nrzc
s��|]}
|
jV
qdSrcrw��.0rurrr�	<genexpr>0��z'get_unique_pull_path.<locals>.<genexpr>c
sr�rcrwr�rrrr�7r�r
r�r�r
�
ro�extendrHryrxr:rrr�parseurl)r�rrqr��default_branches�urlsr0r�rrr�get_unique_pull_path#s*














�



r�c	Cs�g}|
d
urd|jvr|�
dd�|jdD�
�

n.|�d�

n(|
|jvr2|�
dd�|j|
D�
�

nt||
�}|d
u
rB|�|j�

n|�|
�

t|�
dkrm|
d
ur\td�
}|t|�
;}ntd�
}|t|�
|
f;}t�|�
�
|d	}t	||�\}}|||fS)
z@return the `(origsource, path, branch)` selected as clone sourceNrzc
sr�rcrwr�rrrr�Qr�z!get_clone_path.<locals>.<genexpr>c
sr�rcrwr�rrrr�Xr�r
s:default path points to %d urls while only one is supporteds6path points to %d urls while only one is supported: %sr
r�)	rqr�r�r�r0r�r�
clone_path�branchrrr�get_clone_pathLs.













�






r�cCs2t|�
}d
}|j
r|j
}d
|_
t|�
||
pgffS)z5parse url#branch, returning (url, (branch, branches))N)rr2rS)r0�branchesrFr�rrrr�os




r�c@s"eZ
dZd
Zdd�Zddd�
ZdS)roz�Represents a collection of paths and their configs.

    Data is initially derived from ui instances and the config files they have
    loaded.
    cCsJ
t�
|�

tj�d
�
}|
jddd�D]q\}}|sq|
�d|�\}}|
�d|�}|||f}|
j�	||�}	|�	d�
}
|
du
rGt
�|
�
rGt
�|�
}n|g
}g}|D]0}
tj�
|
�
}
tj�|
�
}
t|
�
sqtj�|
�
sqtj�tj�|	|
��
}
t|
||
|d�}|�|�

qN|||<qt|���
D]\}}g}|D]}|�t||
|��

q�|||<q�dS)N�
~�pathsT)
�	ignoresub�
multi-urls)rx�
suboptions)�dictrE�osr0�
expanduser�configitems�configsuboptions�configsource�
_path_to_rootrpr�	parsebool�	parselist�
expandvarsrfrV�normpathrJrHrm�itemsr��_chain_path)r?rq�	home_pathrt�value�_value�sub_optsrQ�root_key�root�	multi_url�	base_locsro�locru�	old_paths�	new_pathsrrrrE�s8
























�zpaths.__init__Nc	Cs�d
}|
�|d�
|dur4|sd}n
t
|ttf�s|f
}|D]}z	||dW
Sty1


YqwdS|s8dS||vrB||dSt|
|�}|durTt�td�
|�
�
|j	S)a
Return a ``path`` from a string, falling back to default.

        ``name`` can be a named path or locations. Locations are filesystem
        paths or URIs.

        Returns None if ``name`` is not a registered path, a URI, or a local
        path to a repo.
        s9getpath is deprecated, use `get_*` functions from urlutils6.0Nrr
r|)
�
deprecwarn�
isinstance�tupler��KeyErrorryrr~rrx)r?rqrt�defaultr��
kr0rrr�getpath�s,	









�






z
paths.getpathrc)rZr[r\r]rEr�rrrrroys
$rocs��
fd
d�}|S)a�
Decorator used to declare a path sub-option.

    Arguments are the sub-option name and the attribute it should set on
    ``path`` instances.

    The decorated function will receive as arguments a ``ui`` instance,
    ``path`` instance, and the string value of this option from the config.
    The function should return the value that will be set on the ``path``
    instance.

    This decorator can be used to perform additional verification of
    sub-options and to change the type of sub-options.
    c

s�|ft�
<|Src)
�_pathsuboptions)
�func��attr�optionrr�register�s

zpathsuboption.<locals>.registerr)r�r�r�rr�r�
pathsuboption�sr�spushurlspushloccCsZt|�
}|j
std
�
}||
j|f;}|�|�

dS|jr)|�td�
|
j�

d|_t|�
S)Ns-(paths.%s:pushurl not a URL; ignoring: "%s")
s:("#fragment" in paths.%s:pushurl not supported; ignoring)
)rr,rrt�warnr2rS)rqr0r�rFr�rrr�pushurlpathoption�s 







���r�spushrevc
Cs|Srcr)rqr0r�rrr�pushrevpathoption�sr�>�ignore�mirrorrzsbookmarks.modesbookmarks_modecCsH|tv
r|
j
}|dur
d
}td�
}|||f;}|�|�

|dkr"d}|S)N�
*s2(paths.%s:bookmarks.mode has unknown value: "%s")
rz)�SUPPORTED_BOOKMARKS_MODESrtrr�)rqr0r��	path_namer�rrr�bookmarks_mode_options








r�r�s
multi_urlscCs.t�
|�
}|dur|�td
�
|
j�

d}|S)Ns.(paths.%s:multi-urls not a boolean; ignoring)
F)rr�r�rrt)rqr0r��resrrr�multiurls_pathoptions



�
r�c
Cs(
g}|jj
d
kr|�|�

|S|jjdusJ�
|�|jj�
}|dur4td�
}||j|jjf;}t�	|�
�
|D][}|�
�}|jj
d
krTtd�
}||j|jjf;}t�	|�
�
|j|_|j|_|j|_|j
durj|j
|_
n|j�dd�d}d||j
f|_|j�
�}	|	�|j�

|�|
|	�
|�|�

q6|S)	z<return the result of "path://" logic applied on a given pathr*Ns)cannot use `%s`, "%s" is not a known paths4cannot use `%s`, "%s" is also defined as a `path://`rr
r
s%s#%s)rr,rHr0rpr/rrxrrrG�raw_urlr�r�r;�
_all_sub_opts�update�
_own_sub_opts�_apply_suboptions)
�	base_pathrqror��	sub_paths�
m�subpathr0�baser�rrrr�"s8


�


























r�c@sPeZ
dZd
Z					ddd�
Zdd�Zdd	�Zd
d�Zdd
�Ze	dd��
Z
dS)r0z4Represents an individual path and its configuration.NTc
Cs�|
d
ur|d
us
J�
|d
usJ�
|d
usJ�
d
S|std�
�
t
|�
}d
}|jr-|j}d
|_||_
|��|_||_||_||_d||_|rI|�	�
|
�
dd�\}}	i|_|d
u
rb|��|_|	�|�

|	��|_
|�|
|	�
d
S)a�
Construct a path from its config options.

        ``ui`` is the ``ui`` instance the path is coming from.
        ``name`` is the symbolic name of the path.
        ``rawloc`` is the raw location, as defined in the config.
        ``pushloc`` is the raw locations pushes should be made to.

        If ``name`` is not defined, we require that the location be a) a local
        filesystem path with a .hg directory or b) a URL. If not,
        ``ValueError`` is raised.
        Nsrawloc must be defineds%sr�r�)rrr2rGr�r�rtrxr��_validate_pathr�r�r�r�r�)
r?rqrtrxr�r�rFr��_pathr�rrrrEFs6





















z
path.__init__c
CsD|��}
|j
��D]\}}t|d
d�}|du
r|�}||
j
|<q	|
S)zmake a copy of this path objectrGN)�	__class__�__dict__r�r)r?�newr�rD�new_copyrrrrGs





z	path.copyc

Cs4|js|j
js|�|j�
std
|j�
�
dSdSdS)Ns1location is not a URL or path to a local repo: %s)rtrr,�_isvalidlocalpathr�rrxrUrrrr��s��
�

���zpath._validate_pathcCsNt�
t�
D]\}\}}||v
rt||d�
q||
|||�}t|||�
qdSrc)rrnr�r)r?rq�sub_options�	suboptionr�r�r�rrrr��s



�zpath._apply_suboptionsc	Cs2ztj
�tj
�|
d
��
WSttfy


YdSw)z�Returns True if the given path is a potentially valid repository.
        This is its own function so that extensions can change the definition of
        'valid' in this case (like when pulling from a git repo into a hg
        one).s.hgF)r�r0�isdirrJ�	TypeErrorrrWrrrr��s


�zpath._isvalidlocalpathc
Cs:i}
t�
t�
D]\}\}}t||�}|d
u
r||
|<q|
S)z{Return sub-options and their values for this path.

        This is intended to be used for presentation purposes.
        N)rrnr�r)r?�
d�suboptr��_funcr�rrrr��s




�
zpath.suboptions)NNNNT)rZr[r\r]rErGr�r�r��propertyr�rrrrr0Cs





�9


r0rc)Nr)
r).r��rer^r�i18nrrrr�rrr	r�
TYPE_CHECKING�typingrr=r�objectrrfr7rhrirkrlrvryr�r�r�r�r�r�r�ror�r�r�r�r�r�r�r�r0rrrr�<module>
sT



[	



)
#
Q








!