
    q&f                        d dl Z d dlZddlmZ ddlmZmZmZmZ ddl	m
Z
mZ  G d dej                        Z G d d	ej                        Z G d
 d      Z G d d      Z G d de      Z G d de      Z G d dee      Z G d de      Z G d dee      Z G d de      Z G d de      Z G d de      Z G d de      Z G d  d!ee      Z G d" d#e      Z G d$ d%e      ZdMd&ZdNd'Z	 	 	 	 	 dOd(Z	 	 	 	 dPd)Z d* Z!d+ Z"	 dQd,Z#d- Z$d. Z%d/ Z&d0 Z'd1 Z(d2 Z)d3 Z*d4 Z+d5 Z,d6 Z-d7 Z.dRd8Z/dRd9Z0dRd:Z1dRd;Z2d< Z3d= Z4de-e5e%ee0e6e2iZ7d> Z8d? Z9d@ Z:dA Z;dSdBZ<dC Z=dD Z>dE Z?dF Z@dG ZAdH ZBdI ZCdJ ZDdK ZEdL ZFy)T    N   )_)errorpycompatsmartsetutil)dateutil
stringutilc                       e Zd Zy)ResourceUnavailableN__name__
__module____qualname__     8/usr/lib/python3/dist-packages/mercurial/templateutil.pyr   r          r   r   c                       e Zd Zy)TemplateNotFoundNr   r   r   r   r   r      r   r   r   c                      e Zd ZdZej
                  Zej                  d        Zej                  d        Z	ej                  d        Z
ej                  d        Zej                  d        Zej                  d        Zej                  d        Zej                  d	        Zej                  d
        Zej                  d        Zy)wrappedzObject requiring extra conversion prior to displaying or processing
    as value

    Use unwrapvalue() or unwrapastype() to obtain the inner object.
    c                      y)zbTest if the specified item is in self

        The item argument may be a wrapped object.
        Nr   selfcontextmappingitems       r   containszwrapped.contains*       r   c                      y)zReturn a member item for the specified key

        The key argument may be a wrapped object.
        A returned object may be either a wrapped object or a pure value
        depending on the self type.
        Nr   r   r   r   keys       r   	getmemberzwrapped.getmember1   r    r   c                      y)zjReturn the smallest item, which may be either a wrapped or a pure
        value depending on the self typeNr   r   r   r   s      r   getminzwrapped.getmin:   r    r   c                      y)ziReturn the largest item, which may be either a wrapped or a pure
        value depending on the self typeNr   r&   s      r   getmaxzwrapped.getmax?   r    r   c                      y)zReturn new container of the same type which includes only the
        selected elements

        select() takes each item as a wrapped object and returns True/False.
        Nr   r   r   r   selects       r   filterzwrapped.filterD   r    r   c                      y)zYield each template mappingNr   r   r   s     r   itermapszwrapped.itermapsL   r    r   c                      y)zJoin items with the separator; Returns a bytes or (possibly nested)
        generator of bytes

        A pre-configured template may be rendered per item if this container
        holds unprintable items.
        Nr   r   r   r   seps       r   joinzwrapped.joinP   r    r   c                      y)zReturn a bytes or (possibly nested) generator of bytes representing
        the underlying object

        A pre-configured template may be rendered if the underlying object is
        not printable.
        Nr   r&   s      r   showzwrapped.showY   r    r   c                      y)z2Return a boolean representation of the inner valueNr   r&   s      r   toboolzwrapped.toboolb   r    r   c                      y)zMove the inner value object out or create a value representation

        A returned value must be serializable by templaterfilters.json().
        Nr   r&   s      r   tovaluezwrapped.tovaluef   r    r   N)r   r   r   __doc__abcABCMeta__metaclass__abstractmethodr   r$   r'   r)   r-   r0   r4   r6   r8   r:   r   r   r   r   r   !   s    KKM  	  	, , 	, , 	  	* * 	  	  	A A 	 r   r   c                   R    e Zd ZdZej
                  Zd Zej                  d        Z	y)mappablez:Object which can be converted to a single template mappingc              #   2   K   | j                  |       y wN)tomapr/   s     r   r0   zmappable.itermapss   s     jj!!s   c                      y)z2Create a single template mapping representing thisNr   r/   s     r   rD   zmappable.tomapv   r    r   N)
r   r   r   r;   r<   r=   r>   r0   r?   rD   r   r   r   rA   rA   n   s/    DKKM" 	A Ar   rA   c                   X    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zy)wrappedbyteszWrapper for byte stringc                     || _         y rC   _valuer   values     r   __init__zwrappedbytes.__init__~   	    r   c                 8    t        |||      }|| j                  v S rC   )	stringifyrJ   r   s       r   r   zwrappedbytes.contains   s    '40t{{""r   c                 ~    t        j                  t        d      t        j                  | j
                        z        Ns   %r is not a dictionaryr   
ParseErrorr   r   bytestrrJ   r"   s       r   r$   zwrappedbytes.getmember   s2    '(8+;+;DKK+HH
 	
r   c                 0    | j                  ||t              S rC   _getbyminr&   s      r   r'   zwrappedbytes.getmin       {{7GS11r   c                 0    | j                  ||t              S rC   rX   maxr&   s      r   r)   zwrappedbytes.getmax   rZ   r   c                     | j                   st        j                  t        d             |t	        j
                  | j                               S )Ns   empty string)rJ   r   rT   r   r   iterbytestr)r   r   r   funcs       r   rX   zwrappedbytes._getby   s9    {{""1_#566H((566r   c                 ~    t        j                  t        d      t        j                  | j
                        z        )Ns   %r is not filterablerS   r+   s       r   r-   zwrappedbytes.filter   s2    %&)9)9$++)FF
 	
r   c                 ~    t        j                  t        d      t        j                  | j
                        z        Ns   %r is not iterable of mappingsrS   r/   s     r   r0   zwrappedbytes.itermaps   s2    /083C3CDKK3PP
 	
r   c                 T    t        t        j                  | j                        |      S rC   )	joinitemsr   r_   rJ   r2   s       r   r4   zwrappedbytes.join   s    --dkk:C@@r   c                     | j                   S rC   rI   r&   s      r   r6   zwrappedbytes.show       {{r   c                 ,    t        | j                        S rC   )boolrJ   r&   s      r   r8   zwrappedbytes.tobool   s    DKK  r   c                     | j                   S rC   rI   r&   s      r   r:   zwrappedbytes.tovalue   rg   r   N)r   r   r   r;   rM   r   r$   r'   r)   rX   r-   r0   r4   r6   r8   r:   r   r   r   rG   rG   {   sB    !#

227




A!r   rG   c                   R    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zy)wrappedvaluez2Generic wrapper for pure non-list/dict/bytes valuec                     || _         y rC   rI   rK   s     r   rM   zwrappedvalue.__init__   rN   r   c                 X    t        j                  t        d      | j                  z        Ns   %r is not iterabler   rT   r   rJ   r   s       r   r   zwrappedvalue.contains   "    q!67$++EFFr   c                 X    t        j                  t        d      | j                  z        rR   rp   r"   s       r   r$   zwrappedvalue.getmember   s"    q!:;dkkIJJr   c                 X    t        j                  t        d      | j                  z        ro   rp   r&   s      r   r'   zwrappedvalue.getmin   rq   r   c                 X    t        j                  t        d      | j                  z        ro   rp   r&   s      r   r)   zwrappedvalue.getmax   rq   r   c                 X    t        j                  t        d      | j                  z        ro   rp   r+   s       r   r-   zwrappedvalue.filter   rq   r   c                 X    t        j                  t        d      | j                  z        rc   rp   r/   s     r   r0   zwrappedvalue.itermaps   s'    /04;;>
 	
r   c                 X    t        j                  t        d      | j                  z        ro   rp   r2   s       r   r4   zwrappedvalue.join   rq   r   c                 Z    | j                   yt        j                  | j                         S Nr   )rJ   r   rU   r&   s      r   r6   zwrappedvalue.show   s$    ;;,,r   c                     | j                   yt        | j                   t              r| j                   S t        t        j                  | j                               S )NF)rJ   
isinstanceri   r   rU   r&   s      r   r8   zwrappedvalue.tobool   sA    ;;dkk4(;;H$$T[[122r   c                     | j                   S rC   rI   r&   s      r   r:   zwrappedvalue.tovalue   rg   r   N)r   r   r   r;   rM   r   r$   r'   r)   r-   r0   r4   r6   r8   r:   r   r   r   rl   rl      sB    <GKGGG

G-
3r   rl   c                   T    e Zd ZdZddZd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zy)datezWrapper for date tuplec                 L    t        t        |      \  | _        | _        || _        y rC   )mapint	_unixtime	_tzoffset_showfmt)r   rL   showfmts      r   rM   zdate.__init__   s     *-S%&r   c                 >    t        j                  t        d            Ns   date is not iterabler   rT   r   r   s       r   r   zdate.contains       q!89::r   c                 >    t        j                  t        d            )Ns   date is not a dictionaryr   r"   s       r   r$   zdate.getmember   s    q!<=>>r   c                 >    t        j                  t        d            r   r   r&   s      r   r'   zdate.getmin   r   r   c                 >    t        j                  t        d            r   r   r&   s      r   r)   zdate.getmax   r   r   c                 >    t        j                  t        d            r   r   r+   s       r   r-   zdate.filter   r   r   c                 >    t        j                  t        d            r   r   r2   s       r   r4   z	date.join   r   r   c                 L    | j                   | j                  | j                  fz  S rC   )r   r   r   r&   s      r   r6   z	date.show   s    }}???r   c                 4    | j                   | j                  dS )N)s   unixtimes   tzoffsetr   r   r/   s     r   rD   z
date.tomap   s    !^^$..IIr   c                      yNTr   r&   s      r   r8   zdate.tobool   s    r   c                 2    | j                   | j                  fS rC   r   r&   s      r   r:   zdate.tovalue   s    //r   N)s   %d %d)r   r   r   r;   rM   r   r$   r'   r)   r-   r4   r6   rD   r8   r:   r   r   r   r~   r~      s>      ;?;;;;@J0r   r~   c                   `    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zd Zd Zd Zy)hybrida  Wrapper for list or dict to support legacy template

    This class allows us to handle both:
    - "{files}" (legacy command-line-specific list hack) and
    - "{files % '{file}
'}" (hgweb-style with inlining and function support)
    and to access raw values:
    - "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}"
    - "{get(extras, key)}"
    - "{files|json}"
    Nc                 J    || _         || _        || _        || _        || _        y rC   )_gen_values_makemap_joinfmt_keytype)r   genvaluesmakemapjoinfmtkeytypes         r   rM   zhybrid.__init__  s%    	r   c                 N    t        |||| j                        }|| j                  v S rC   )unwrapastyper   r   r   s       r   r   zhybrid.contains  s%    GWdDMMBt||##r   c                     t        | j                  d      st        j                  t	        d            t        |||| j                        }| j                  || j                  j                  |            S )Nget   not a dictionary)	hasattrr   r   rT   r   r   r   
_wrapvaluer   r"   s       r   r$   zhybrid.getmember  s[    t||U+""1%8#9::7GS$--@sDLL$4$4S$9::r   c                 0    | j                  ||t              S rC   rW   r&   s      r   r'   zhybrid.getmin   rZ   r   c                 0    | j                  ||t              S rC   r\   r&   s      r   r)   zhybrid.getmax#  rZ   r   c                     | j                   st        j                  t        d             || j                         }| j	                  ||      S Ns   empty sequence)r   r   rT   r   r   )r   r   r   r`   vals        r   rX   zhybrid._getby&  s?    ||""1%6#7884<< sC((r   c                 T    |y t        |d      r|S t        d ||| j                        S )Nr   )r   
hybriditemr   )r   r#   r   s      r   r   zhybrid._wrapvalue,  s.    ;3
#J$S$--88r   c           
         t        | j                  d      rF| j                  j                         D ci c]   \  }} || j                  ||            r||" }}}n2| j                  D cg c]  } || j                  ||            s| }}t	        d || j
                  | j                  | j                        S c c}}w c c}w Nr   )r   r   itemsr   r   r   r   r   )r   r   r   r,   kvr   s          r   r-   zhybrid.filter4  s    4<<' !LL..0Aq$//!Q/0 1F  "&OA18M1NaOFOdFDMM4==$--PP Ps   %B<+C	Cc              #   Z   K   | j                   }| j                  D ]  } ||        y wrC   )r   r   )r   r   r   xs       r   r0   zhybrid.itermaps?  s,     -- 	A!*	s   )+c                 B     t         fd j                  D        |      S )Nc              3   @   K   | ]  }j                  |        y wrC   )r   ).0r   r   s     r   	<genexpr>zhybrid.join.<locals>.<genexpr>F  s     Aq$--*As   )re   r   r2   s   `   r   r4   zhybrid.joinD  s    ADLLA3GGr   c                 l    | j                   }|| j                  ||d      S t        |      r |       S |S N    )r   r4   callabler   r   r   r   s       r   r6   zhybrid.showH  s6    ii;99Wgt44C=5L
r   c                 ,    t        | j                        S rC   )ri   r   r&   s      r   r8   zhybrid.toboolQ  s    DLL!!r   c           
          | j                   }t        |d      r/|j                         D ci c]  \  }}|t        |||       c}}S |D cg c]  }t        |||       c}S c c}}w c c}w r   )r   r   r   unwrapvalue)r   r   r   xsr   r   r   s          r   r:   zhybrid.tovalueT  sa    \\2uDFHHJODAqA{7GQ77OO:<=QGWa0== P=s   A#A)rC   )r   r   r   r;   rM   r   r$   r'   r)   rX   r   r-   r0   r4   r6   r8   r:   r   r   r   r   r     sJ    	 $;22)9	Q
H">r   r   c                   R    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zy)r   zWrapper for non-list/dict object to support map operation

    This class allows us to handle both:
    - "{manifest}"
    - "{manifest % '{rev}:{node}'}"
    - "{manifest.rev}"
    c                 <    || _         || _        || _        || _        y rC   )r   _keyrJ   r   )r   r   r#   rL   r   s        r   rM   zhybriditem.__init__e  s    		r   c                 8    | j                  | j                        S rC   )r   r   r/   s     r   rD   zhybriditem.tomapk  s    }}TYY''r   c                 V    t        ||| j                        }|j                  |||      S rC   )makewrappedrJ   r   )r   r   r   r   ws        r   r   zhybriditem.containsn  s'    $++6zz'7D11r   c                 V    t        ||| j                        }|j                  |||      S rC   )r   rJ   r$   )r   r   r   r#   r   s        r   r$   zhybriditem.getmemberr  s'    $++6{{7GS11r   c                 T    t        ||| j                        }|j                  ||      S rC   )r   rJ   r'   r   r   r   r   s       r   r'   zhybriditem.getminv  %    $++6xx))r   c                 T    t        ||| j                        }|j                  ||      S rC   )r   rJ   r)   r   s       r   r)   zhybriditem.getmaxz  r   r   c                 V    t        ||| j                        }|j                  |||      S rC   )r   rJ   r-   )r   r   r   r,   r   s        r   r-   zhybriditem.filter~  s'    $++6xx&11r   c                 V    t        ||| j                        }|j                  |||      S rC   )r   rJ   r4   )r   r   r   r3   r   s        r   r4   zhybriditem.join  s'    $++6vvgw,,r   c                     | j                   }|t        j                  | j                        S t	        |      r |       S |S rC   )r   r   rU   rJ   r   r   s       r   r6   zhybriditem.show  s8    ii;##DKK00C=5L
r   c                 T    t        ||| j                        }|j                  ||      S rC   )r   rJ   r8   r   s       r   r8   zhybriditem.tobool  r   r   c                 0    t        ||| j                        S rC   )_unthunkrJ   r&   s      r   r:   zhybriditem.tovalue  s    $++66r   N)r   r   r   r;   rM   rD   r   r$   r'   r)   r-   r4   r6   r8   r:   r   r   r   r   r   \  s>     (22**2-*7r   r   c                   `    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zd Zd Zd Zy)revslistaZ  Wrapper for a smartset (a list/set of revision numbers)

    If name specified, the revs will be rendered with the old-style list
    template of the given name by default.

    The cachekey provides a hint to cache further computation on this
    smartset. If the underlying smartset is dynamically created, the cachekey
    should be None.
    Nc                 t    t        |t        j                        sJ || _        || _        || _        || _        y rC   )r{   r   abstractsmartset_repo_revs_namecachekey)r   reporevsnamer   s        r   rM   zrevslist.__init__  s4    $ 9 9:::


 r   c                 8    t        |||      }|| j                  v S rC   )unwrapintegerr   )r   r   r   r   revs        r   r   zrevslist.contains  s    GWd3djj  r   c                 >    t        j                  t        d            Nr   r   r"   s       r   r$   zrevslist.getmember      q!4566r   c                 b    | j                         } || j                  j                               S rC   )_makehybriditemfuncr   rY   r   r   r   makehybriditems       r   r'   zrevslist.getmin  &    113djjnn.//r   c                 b    | j                         } || j                  j                               S rC   )r   r   r]   r   s       r   r)   zrevslist.getmax  r   r   c                     | j                         | j                  j                  fd      }t        | j                  |d       S )Nc                        |             S rC   r   )rr   r,   s    r   <lambda>z!revslist.filter.<locals>.<lambda>  s    F>!3D,E r   )r   )r   r   r-   r   r   )r   r   r   r,   frevsr   s      ` @r   r-   zrevslist.filter  s9    113

!!"EF

E55r   c              #   b   K   | j                         }| j                  D ]  } ||        y wrC   )_makemapfuncr   )r   r   r   r   s       r   r0   zrevslist.itermaps  s1     ##% 	A!*	s   -/c                 .    | j                         fdS )Nc                      t        d | |       S rC   )r   )r   r   s    r   r   z.revslist._makehybriditemfunc.<locals>.<lambda>  s    D!Q8 r   )r   )r   r   s    @r   r   zrevslist._makehybriditemfunc  s    ##%88r   c                 P    | j                   | j                  rfdS fdS )Nc                     | d|    iS Ns   ctxr   )r   r   r   s    r   r   z'revslist._makemapfunc.<locals>.<lambda>  s    dAvtAw7 r   c                     d|    iS r   r   )r   r   s    r   r   z'revslist._makemapfunc.<locals>.<lambda>  s    fd1g. r   )r   r   )r   r   r   s    @@r   r   zrevslist._makemapfunc  s$    zzzz77..r   c                 .    t        | j                  |      S rC   )re   r   r2   s       r   r4   zrevslist.join  s    S))r   c                     | j                   r4| j                  D cg c]  }d|z  	 }}t        ||| j                   |      S | j                  ||d      S c c}w )Ns   %dr   )r   r   _showcompatlistr4   )r   r   r   r   srevss        r   r6   zrevslist.show  sQ    ::(,

31UQY3E3"7GTZZGG99Wgt44 4s   Ac                 ,    t        | j                        S rC   )ri   r   r&   s      r   r8   zrevslist.tobool  s    DJJr   c                     | j                   S rC   )r   r&   s      r   r:   zrevslist.tovalue  s    zzr   NN)r   r   r   r;   rM   r   r$   r'   r)   r-   r0   r   r   r4   r6   r8   r:   r   r   r   r   r     sH    !!7006
9/*5 r   r   c                   H    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zy)_mappingsequencezWrapper for sequence of template mappings

    This represents an inner template structure (i.e. a list of dicts),
    which can also be rendered by the specified named/literal template.

    Template mappings may be nested.
    Nc                 `    ||t        j                  d      || _        || _        || _        y )Ns$   name and tmpl are mutually exclusive)r   ProgrammingErrorr   _tmpl_defaultsep)r   r   tmplr3   s       r   rM   z_mappingsequence.__init__  s;     0((7  

r   c                 >    t        j                  t        d            Ns   not comparabler   r   s       r   r   z_mappingsequence.contains      q!2344r   c                 >    t        j                  t        d            r   r   r"   s       r   r$   z_mappingsequence.getmember  r   r   c                 >    t        j                  t        d            r	  r   r&   s      r   r'   z_mappingsequence.getmin  r
  r   c                 >    t        j                  t        d            r	  r   r&   s      r   r)   z_mappingsequence.getmax  r
  r   c                 >    t        j                  t        d            )Ns   not filterable without templater   r+   s       r   r-   z_mappingsequence.filter  s    q!CDEEr   c                      t        | j                              } j                  r fd|D        }n7 j                  r fd|D        }nt	        j
                  t        d            t        ||      S )Nc              3   V   K   | ]   }j                  j                  |       " y wrC   )processr   r   mr   r   s     r   r   z(_mappingsequence.join.<locals>.<genexpr>  s      I1

A6I   &)c              3   V   K   | ]   }j                  j                  |       " y wrC   )expandr  r  s     r   r   z(_mappingsequence.join.<locals>.<genexpr>  s      H!tzz15Hr  s    not displayable without template)_iteroverlaymapsr0   r   r  r   rT   r   re   )r   r   r   r3   mapsiteritemiters   ``    r   r4   z_mappingsequence.join  s`    #GWdmmG6LM::IIHZZHxHH""1%H#IJJ3''r   c                 <    | j                  ||| j                        S rC   )r4   r  r&   s      r   r6   z_mappingsequence.show  s    yy'4+;+;<<r   c                 
   |j                         }g }| j                  |      D ]V  }|j                  ||      }|j                  |j	                         D ci c]  \  }}||vr|t        |||       c}}       X |S c c}}w rC   )knownresourcekeysr0   
overlaymapappendr   r   )	r   r   r   knownresr   nmlmr   r   s	            r   r:   z_mappingsequence.tovalue  s    ,,.--( 		B##GR0BLL !#
1( {7B22		 s   A?NNr   )r   r   r   r;   rM   r   r$   r'   r)   r-   r4   r6   r:   r   r   r   r  r    s5    5755F(=r   r  c                   0     e Zd ZdZd fd	Zd Zd Z xZS )mappinggeneratorzWrapper for generator of template mappings

    The function ``make(context, *args)`` should return a generator of
    mapping dicts.
    c                 L    t         t        |   |||       || _        || _        y rC   )superr$  rM   _make_args)r   makeargsr   r  r3   	__class__s         r   rM   zmappinggenerator.__init__&  s%    .tT3?

r   c                 <     | j                   |g| j                   S rC   r'  r(  r/   s     r   r0   zmappinggenerator.itermaps+      tzz'/DJJ//r   c                 6    t        | j                  |            S rC   )	_nonemptyr0   r&   s      r   r8   zmappinggenerator.tobool.  s    w/00r   )r   NNr   r   r   r   r;   rM   r0   r8   __classcell__r+  s   @r   r$  r$    s    
01r   r$  c                   0     e Zd ZdZd fd	Zd Zd Z xZS )mappinglistz%Wrapper for list of template mappingsc                 >    t         t        |   |||       || _        y rC   )r&  r5  rM   	_mappings)r   mappingsr   r  r3   r+  s        r   rM   zmappinglist.__init__5  s    k4)$c:!r   c                 ,    t        | j                        S rC   )iterr7  r/   s     r   r0   zmappinglist.itermaps9      DNN##r   c                 ,    t        | j                        S rC   )ri   r7  r&   s      r   r8   zmappinglist.tobool<  r;  r   r"  r1  r3  s   @r   r5  r5  2  s    /"$$r   r5  c                   :     e Zd ZdZd fd	Zd Zd Z fdZ xZS )mappingdictzWrapper for a single template mapping

    This isn't a sequence in a way that the underlying dict won't be iterated
    as a dict, but shares most of the _mappingsequence functions.
    c                 <    t         t        |   ||       || _        y rC   )r&  r>  rM   _mapping)r   r   r   r  r+  s       r   rM   zmappingdict.__init__G  s    k4)$5r   c                     | j                   S rC   )r@  r/   s     r   rD   zmappingdict.tomapK  s    }}r   c                      yr   r   r&   s      r   r8   zmappingdict.toboolN  s     r   c                 2    t         t        |   ||      d   S )Nr   )r&  r>  r:   )r   r   r   r+  s      r   r:   zmappingdict.tovalueT  s    [$/A!DDr   r   )	r   r   r   r;   rM   rD   r8   r:   r2  r3  s   @r   r>  r>  @  s#     E Er   r>  c                   (     e Zd ZdZ fdZd Z xZS )mappingnonezWrapper for None, but supports map operation

    This represents None of Optional[mappable]. It's similar to
    mapplinglist([]), but the underlying value is not [], but None.
    c                 ,    t         t        |   d        y rC   )r&  rE  rM   )r   r+  s    r   rM   zmappingnone.__init___  s    k4)$/r   c                     t        g       S rC   )r:  r/   s     r   r0   zmappingnone.itermapsb  s    Bxr   )r   r   r   r;   rM   r0   r2  r3  s   @r   rE  rE  X  s    0r   rE  c                   p    e Zd ZdZddZd Zd Zd Zd Zd Z	d Z
ed	        Zd
 Zd Zd Zd Zd Zd Zy)mappedgeneratora  Wrapper for generator of strings which acts as a list

    The function ``make(context, *args)`` should return a generator of
    byte strings, or a generator of (possibly nested) generators of byte
    strings (i.e. a generator for a list of byte strings.)
    c                      || _         || _        y rC   r-  )r   r)  r*  s      r   rM   zmappedgenerator.__init__n  s    

r   c                 D    t        |||      }|| j                  ||      v S rC   )rP   r:   r   s       r   r   zmappedgenerator.containsr  s&    '40t||GW555r   c                 <     | j                   |g| j                   S rC   r-  r/   s     r   r   zmappedgenerator._genv  r.  r   c                 >    t        j                  t        d            r   r   r"   s       r   r$   zmappedgenerator.getmembery  r   r   c                 0    | j                  ||t              S rC   rW   r&   s      r   r'   zmappedgenerator.getmin|  rZ   r   c                 0    | j                  ||t              S rC   r\   r&   s      r   r)   zmappedgenerator.getmax  rZ   r   c                 v    | j                  ||      }|st        j                  t        d             ||      S r   )r:   r   rT   r   )r   r   r   r`   r   s        r   rX   zmappedgenerator._getby  s5    \\'7+""1%6#788Bxr   c              #   n   K    || g| D ]%  }t        | ||      } |t        |            s"| ' y wrC   )rP   rG   )r   r   r)  r*  r,   r   ss          r   _filteredgenzmappedgenerator._filteredgen  s>     g%% 	A'7A.Al1o&	s   +55c                 b    || j                   | j                  |f}t        | j                  |      S rC   )r'  r(  rI  rS  )r   r   r   r,   r*  s        r   r-   zmappedgenerator.filter  s+    TZZ8t00$77r   c                 >    t        j                  t        d            )Ns   list of strings is not mappabler   r/   s     r   r0   zmappedgenerator.itermaps  s    q!CDEEr   c                 8    t        | j                  |      |      S rC   )re   r   r2   s       r   r4   zmappedgenerator.join  s    7+S11r   c                 (    | j                  ||d      S ry   )r4   r&   s      r   r6   zmappedgenerator.show  s    yy'3//r   c                 6    t        | j                  |            S rC   )r0  r   r&   s      r   r8   zmappedgenerator.tobool  s    7+,,r   c                 `    | j                  |      D cg c]  }t        |||       c}S c c}w rC   )r   rP   )r   r   r   r   s       r   r:   zmappedgenerator.tovalue  s(    8<		'8JK1	'7A.KKKs   +N)r   )r   r   r   r;   rM   r   r   r$   r'   r)   rX   staticmethodrS  r-   r0   r4   r6   r8   r:   r   r   r   rI  rI  f  s^    60722  8F20-Lr   rI  c                      t         j                  dt         j                  t        |  fd fd      S )z>Wrap data to support both dict-like and string-like operationss   %s=%sc                     | |    iS rC   r   )r   datar#   rL   s    r   r   zhybriddict.<locals>.<lambda>  s    35$q'* r   c                 0     |        |          fz  S rC   r   )r   r]  fmtprefmts    r   r   zhybriddict.<locals>.<lambda>  s    #F47O44 r   r   identityrU   r   )r]  r#   rL   r_  r   r`  s   ```` @r   
hybriddictrc    s<    F
{!!*4	 r   c                 z    t         j                  dt         j                  t        || fdfd      S )z>Wrap data to support both list-like and string-like operationss   %sc                     | iS rC   r   )r   r   s    r   r   zhybridlist.<locals>.<lambda>  s    ay r   c                      |       z  S rC   r   )r   r_  r`  s    r   r   zhybridlist.<locals>.<lambda>  s    C&)O r   ra  )r]  r   r_  r   r`  s    `` @r   
hybridlistrg    s6    F
{!!#t02KLLr   c	                     |j                         D 	
cg c]  \  }	}
||	||
i }}	}
t        | |||||      }t        |||||      S c c}
}	w )zWrap data like hybriddict(), but also supports old-style list template

    This exists for backward compatibility with the old-style template. Use
    hybriddict() for new template keywords.
    )r#   rL   r_  r   )r   r   rc  )r   r   r   r]  r#   rL   r_  plural	separatorr   r   cfs                r   
compatdictrm    sV      )-

51#q%	5A5$69EAd5cqAA 	6s   Ac                 H    t        | |||||      }t        ||xs |||      S )zWrap data like hybridlist(), but also supports old-style list template

    This exists for backward compatibility with the old-style template. Use
    hybridlist() for new template keywords.
    )r   r_  r   )r   rg  )	r   r   r   r]  elementr_  ri  rj  rl  s	            r   
compatlistrp    s-     	$fiHAdDcqAAr   c                     D cg c]
  \  }}||d }}}t        | |||d      }t        j                        t        |fdfd      S c c}}w )zWrap list of (dest, source) file names to support old-style list
    template and field names

    This exists for backward compatibility. Use hybriddict for new template
    keywords.
    )   name   sources   file_copies)ri  c                     | | |    dS )N)rr     pathrs  r   r   copiess    r   r   z&compatfilecopiesdict.<locals>.<lambda>  s    AfQi@ r   c                     d| |    fz  S )Ns   %s (%s)r   rv  s    r   r   z&compatfilecopiesdict.<locals>.<lambda>  s    *6!9~- r   )r   r   sortdictr   )r   r   r   rw  r   r   rk  rl  s      `    r   compatfilecopiesdictrz    s_     17711	#7A7$.IA]]6"F	@-	  	8s   Ac                 X    t        | |||      }t        ||d t        j                        S )zWrap list of file names to support old-style list template and field
    names

    This exists for backward compatibility. Use hybridlist for new template
    keywords.
    c                     | | dS )N)s   fileru  r   )r   s    r   r   z!compatfileslist.<locals>.<lambda>  s    a!4 r   )r   r   r   rb  )r   r   r   filesrl  s        r   compatfileslistr~    s1     	$6A	54h6G6G r   c              #      K   |sdz   }|s+d|z   } j                  |      r j                  |       y j                        sOt        |d   t              r|j	                  |       y|D ]"  }t        |      }|j                         | $ yd|z   }	 j                  |	      r j                  |	       f fd	}
dz   } j                  |      r|j                         }nd}|D ]  } |
|        | |
||       d	|z   } j                  |      r j                  |       yyw)
aN  Return a generator that renders old-style list template

    name is name of key in template map.
    values is list of strings or dicts.
    plural is plural of name, if not simply name + 's'.
    separator is used to join values as a string

    expansion works like this, given name 'foo'.

    if values is empty, expand 'no_foos'.

    if 'foo' not in template map, return values as a string,
    joined by 'separator'.

    expand 'start_foos'.

    for each value, expand 'foo'. if 'last_foo' in template
    map, expand it instead of 'foo' for last key.

    expand 'end_foos'.
       ss   no_Nr   s   start_c                     i }	 |j                  |        j	                  |      }j                  ||      S # t        t        t        f$ r. 	 | D ]
  \  }}|||<    n# t        t        f$ r | |<   Y nw xY wY ew xY wrC   )updateAttributeError	TypeError
ValueErrorr  r  )r   tagvmappingabr   r   r   s        r   onez_showcompatlist.<locals>.one.  s    	#OOA %%gx8sH-- 	:6 	##  $DAq"#HQK$z* #!"#	#s3   : A<AA<A63A<5A66A<;A<s   last_)r  s   end_)preloadr  r{   bytesr4   dictr  pop)r   r   r   r   ri  rj  nonamer   r   	startnamer  lastnamelastendnames   ```           r   r   r     sL    0 &??6"//&'22??4 fQi'..(( 		  G! 	F"Iy!ooi11 ." $Hx zz| !f$H%%Gwoogw//  s   D<Ec              #     K   t        |t              r|j                  | |      }t        |t              r| yt        |t              rt        j                  d|z        |yt        |d      st        j                  |       y|D ]v  }t        |t              r|j                  | |      }t        |t              r| :|=t        |d      st        j                  |       at        | ||      D ]  }|  x yw)z=Yield a single stream from a possibly nested set of iteratorssH   Mercurial IO including templates is done with bytes, not strings, got %rN__iter__)r{   r   r6   r  strr   r  r   r   rU   flatten)r   r   thingijs        r   r  r  M  s     %!

7G,%	E3	 $$0278
 	
 
UJ'u%% 	A!W%FF7G,!U#Q
+&&q)) '15 AG	s   DDc                 ^    t        |t              r|S dj                  t        | ||            S )zETurn values into bytes by converting into text and concatenating themr   )r{   r  r4   r  r   r   r  s      r   rP   rP   m  s)    %88GGWe455r   c                 B    	 | \  }}|t         u r|S |t        u r|d   } ny)z`Find symbolic name for the given compiled expression; returns None
    if nothing found reliablyr   N)	runsymbol	runfilter)argr`   r]  s      r   findsymbolicnamer  t  s6     
d9KYq'C r   c                 :    	 t        |        y# t        $ r Y yw xY w)NTF)nextStopIteration)xiters    r   r0  r0    s#    U s    	c                 T    t        |t        j                        s|S t        | ||      S )z&Evaluate a lazy byte string into value)r{   typesGeneratorTyperP   r  s      r   r   r     s&    eU001Wgu--r   c                      |\  }} || ||      S )zEvaluate given argument as a bare template object which may require
    further processing (such as folding generator of strings)r   )r   r   r  r`   r]  s        r   
evalrawexpr    s     JD$$''r   c                 6    t        | ||      }t        | ||      S )z)Evaluate given argument to wrapped object)r  r   )r   r   r  r  s       r   evalwrappedr    s    w-Ew//r   c                     t        |t              r|S t        | ||      }t        |t              rt	        |      S t        |      S )zLift object to a wrapped type)r{   r   r   r  rG   rl   r  s      r   r   r     s?    %!Wgu-E%E""r   c           	      2    t        | |t        | ||            S )z%Evaluate given argument as value type)r   r  r   r   r  s      r   evalfuncargr    s    wGWc)JKKr   c                 `    t        |t              r|j                  | |      S t        | ||      S )z.Move the inner value object out of the wrapper)r{   r   r:   r   r  s      r   r   r     s.    %!}}Wg.. GWe,,r   c                     |\  }}|t         u r$ || ||d      }| t        j                  |      }n
 || ||      }t        | ||      j	                  | |      S )zCEvaluate given argument as boolean, but also takes boolean literalsNdefault)r  r
   	parseboolr   r8   r   r   r  r`   r]  r  s         r   evalbooleanr    sb    JD$yWgtT:=((.EWgt,w/66wHHr   c                 8    t        | ||      }t        | |||      S )z`Evaluate given argument as a date tuple or a date string; returns
    a (unixtime, offset) tuple)r  
unwrapdater   r   r  errr  s        r   evaldater    s#     w-Egws33r   c                 >   t        |t              r|j                  | |      S t        | ||      }	 t	        j
                  |      S # t        $ r# t        j                  |xs t        d            t        j                  $ r |s t        j                  |      w xY w)Ns   not a date tuple nor a string)
r{   r~   r:   r   r	   	parsedater  r   rT   r   r   r   r  r  s       r   r  r    s    %}}Wg..%0E$!!%(( KsIa(H&IJJ $s##$s   A ABc                 8    t        | ||      }t        | |||      S rC   )r  r   r  s        r   evalintegerr    s!    w-E'5#66r   c                     t        | ||      }	 t        |      S # t        t        f$ r# t	        j
                  |xs t        d            w xY w)Ns   not an integer)r   r   r  r  r   rT   r   r  s       r   r   r     sO    %0E<5zz" <s:a(9&:;;<s	   
 2Ac           	      2    t        | |t        | ||            S rC   )rP   r  r  s      r   
evalstringr    s    Wgz'7C'HIIr   c                 d    |\  }}|t         u r || |||      }n
 || ||      }t        | ||      S )zXEvaluate given argument as string template, but returns symbol name
    if it is unknownr  )r  rP   r  s         r   evalstringliteralr    sB     JD$yWgtT:Wgt,Wgu--r   c                 t    	 t         |   } || ||      S # t        $ r t        j                  d|z        w xY w)zBMove the inner value object out of the wrapper and coerce its types   invalid type specified: %r)_unwrapfuncbytypeKeyErrorr   r  )r   r   r  typrl  s        r   r   r     sM    Jc" Wgu%%  J$$%BS%HIIJs   	 "7c                     t        |      S rC   )r   r   r   r]  s      r   
runintegerr    s    t9r   c                     |S rC   r   r  s      r   	runstringr  	  s    Kr   c                       fd}|S )Nc                 F    t        j                  t        d      z        )Ns$   recursive reference '%s' in template)r   Abortr   )r   r   r#   s     r   showrecursionz._recursivesymbolblocker.<locals>.showrecursion  s    kk!CDsJKKr   r   )r#   r  s   ` r   _recursivesymbolblockerr    s    L r   c                     | j                  ||      }|1|j                         }t        |      ||<   	 | j                  ||      }t        |      r
	  || |      S |S # t        $ r |}Y $w xY w# t        $ r Y y w xY wrC   )symbolcopyr  r  r   r   r   )r   r   r#   r  r   safemappings         r   r  r    s    w$Ay lln237C	[1A {	Wg&& H   	A	 # 		s#   A A. A+*A+.	A:9A:c              #   8   K   |D ]  }t        | ||        y wrC   )r  )r   r   templater  s       r   runtemplater  )  s$      0'3//0s   c                     |\  }}t        | ||      }t        |dd       }	 t        | |||      } ||      S # t        j                  $ r/}t        j                  t        |      t        ||            d }~ww xY w)N_intypehint)r  getattrr   r   rT   r  _formatfiltererror)r   r   r]  r  filtr  intypees           r   r  r  .  s~    ICw-ET9d+FMWguf=E{ MuQx.@d.KLLMs   7 A9
*A44A9c                     t        j                  |j                        }t        |       }|st	        d      |z  S t	        d      ||fz  S )Ns(   incompatible use of template filter '%s's8   template filter '%s' is not compatible with keyword '%s')r   sysbytesr   r  r   )r  r  fnsyms       r   r  r  9  sS    			4==	)B
3
C<=BBHI
M  r   c              #   h   K   t        |      D ]   \  }}| j                  ||      }||d<   | " yw)zuGenerate combined mappings from the original mapping and an iterable
    of partial mappings to override the originals   indexN)	enumerater  )r   origmappingnewmappingsr  r   r!  s         r   r  r  D  s@      ;' 2R08s   02c              #      K   	 |j                  |       }t        | ||      D ]  }	t        | |	|        y # t        j                  $ rA}t        |      }|s t	        d      |z  }t        j                  t        |      |      d }~ww xY ww)Ns+   keyword '%s' does not support map operationr  )r0   r   rT   r  r   r  r  r  )
r   r   ddargtargditerr  r  r  r!  s
             r   	_applymapr  M  s     6

7# w7 ,"d++,  6t$?@3FuSz556s%   B7 "BB
<BBBc                 P    |\  }}t        | ||      }t        t        ||||f      S )N)r*  )r  rI  r  )r   r   r]  r  r  r  s         r   runmapr  Z  s/    JD$GWd+A9GQd+CDDr   c                 x   |\  }}t        | ||      }t        |t              r.| j                  ||j	                  |             }t        | ||      S 	 |j                  | ||      S # t        j                  $ rA}t        |      }|s t        d      |z  }	t        j                  t        |      |	      d }~ww xY w)Ns.   keyword '%s' does not support member operationr  )r  r{   rA   r  rD   r  r$   r   rT   r  r   r  )
r   r   r]  r  membr  r!  r  r  r  s
             r   	runmemberr  `  s    JD$GWd+A!X)9:"d++6{{7GT22 6t$BCcIuSz556s   A% %B98<B44B9c                 6    t        | ||t        d            }| S )Ns"   negation needs an integer argument)r  r   r  s      r   	runnegater  p  s$    $"G HD 5Lr   c                     |\  }}}t        | ||t        d            }t        | ||t        d            }	  |||      S # t        $ r t        j                  t        d            w xY w)Ns#   arithmetic only defined on integerss   division by zero is not defined)r  r   ZeroDivisionErrorr   r  )r   r   r]  r`   leftrights         r   runarithmeticr  w  s{    D$$"H ID %#I!JEAD%   Akk!>?@@As	   ? (A'c              #   <   K   d}| D ]  }|rd}n|r| |  yw)z9Join items with the separator; Returns generator of bytesTFNr   )r  r3   firstr   s       r   re   re     s/     E EIs   )   key   valueNNr   )r  r  NNr   )NNNr   r   rC   )r   )Gr<   r  i18nr    r   r   r   r   utilsr	   r
   r  r   r   r   rA   rG   rl   r~   r   r   r   r  r$  r5  r>  rE  rI  rc  rg  rm  rp  rz  r~  r   r  rP   r  r0  r   r  r  r   r  r   r  r  r  r  r   r  r  r  r   r  r   r  r  r  r  r  r  r  r  r  r  r  r  r  re   r   r   r   <module>r     s      	%++ 		u{{ 	J JZ
A 
A.7 .b+7 +\%08W %0PW>W W>t877 87vFw FR<w <~1' 1&$" $E(, E0, :Lg :LzM 	
B4 B&&
 <@H0V@6
.(0L
-
I4$7
<J. 	+	9*	 &*0
M
,E6 Ar   