-=[ Mr. Bumblebee ]=-
_Indonesia_
Nc @@ s d d l m Z d d l m Z d d l Z d d l m Z d d d g Z d Z d Z d
Z d Z
d e j f d
YZ d S( i ( t absolute_import( t bisectN( t muttert PatienceSequenceMatchert unified_difft unified_diff_filesc C@ s} i } xG t t | D]3 } | | } | | k rB d | | <q | | | <q Wd g t | } i } xp t | D]b \ } } | j | } | d k rv | | k r d | | | <| | =q | | | <| | | <qv qv Wd g t | } g }
g } d } xt | D]\ }
} | d k r,qn |
rQ|
d | k rQt |
} n\ |
r|
| | k r| t |
d k s|
| d | k r| d 7} n t |
| } | d k r| | d | |
<n | t |
k r| |
| <|
| | <q|
j | | j |
qWt | d k r+g Sg } | d } x1 | d k rn| j | | | f | | } q>W| j | S( s3 Find the longest common subset for unique lines.
:param a: An indexable object (such as string or list of strings)
:param b: Another indexable object (such as string or list of strings)
:return: A list of tuples, one for each line which is matched.
[(line_in_a, line_in_b), ...]
This only matches lines which are unique on both sides.
This helps prevent common lines from over influencing match
results.
The longest common subset uses the Patience Sorting algorithm:
http://en.wikipedia.org/wiki/Patience_sorting
i ii N( t xranget lent Nonet enumeratet getR t appendt reverse( t at bt indext it linet btoat index2t post nextt backpointerst stackst lastst kt bpost apost result( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyt
unique_lcs_py sZ
,
c C@ s | d k r t d d St | } | | k s> | | k rB d S| d } | d }
x t | | | !| | | ! D] \ } } | | 7} | | 7} | d | k s |
d | k r t | | | d |
d | | | | d n | } | }
| j | | f qt Wt | | k rEt | | | d |
d | | | | d nw| | | | k rxW | | k r| | k r| | | | k r| j | | f | d 7} | d 7} q\Wt | | | | | | | | d n | | d | | d k r| d }
| d } xL |
| k rW| | k rW| |
d | | d k rW|
d 8}
| d 8} q Wt | | | d |
d |
| | | d x6 t | |
D]! } | j |
| | | f qWn d S( s Find all of the matching text in the lines of a and b.
:param a: A sequence
:param b: Another sequence
:param alo: The start location of a to check, typically 0
:param ahi: The start location of b to check, typically 0
:param ahi: The maximum length of a to check, typically len(a)
:param bhi: The maximum length of b to check, typically len(b)
:param answer: The return array. Will be filled with tuples
indicating [(line_in_a, line_in_b)]
:param maxrecursion: The maximum depth to recurse.
Must be a positive integer.
:return: None, the return value is in the parameter answer, which
should be a list
i s max recursion depth reachedNi ( R R R t recurse_matches_pyR R ( R
R t alot blot ahit bhit answert maxrecursiont oldlengtht
last_a_post
last_b_posR R t nahit nbhiR ( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyR k sJ
*
/
7
c C@ s g } d } } d } x | D]| \ } } | d k rb | | | k rb | | | k rb | d 7} q | d k r | j | | | f n | } | } d } q W| d k r | j | | | f n | S( s Find sequences of lines.
Given a sequence of [(line_in_a, line_in_b),]
find regions where they both increment at the same time
i i N( R R ( t matchesR# t start_at start_bt lengtht i_at i_b( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyt _collapse_sequences s
c C@ st d } d } xa | D]Y \ } } } | | k r= t d n | | k rX t d n | | } | | } q Wd S( Nis Non increasing matches for as Non increasing matches for b( t
ValueError( R# t next_at next_bR
R t match_len( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyt _check_consistency s
t PatienceSequenceMatcher_pyc B@ s/ e Z d Z e Z d d d d Z d Z RS( s8 Compare a pair of sequences using longest common subset.t c C@ s8 | d k r t d n t j j | | | | d S( Ns8 Currently we do not support isjunk for sequence matching( R t NotImplementedErrort difflibt SequenceMatchert __init__( t selft isjunkR
R ( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyR; s c C@ s | j d k r | j Sg } t | j | j d d t | j t | j | d t | | _ | j j t | j t | j d f t j r t
| j n | j S( s Return list of triples describing matching subsequences.
Each triple is of the form (i, j, n), and means that
a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
i and in j.
The last triple is a dummy, (len(a), len(b), 0), and is the only
triple with n==0.
>>> s = PatienceSequenceMatcher(None, "abxcd", "abcd")
>>> s.get_matching_blocks()
[(0, 0, 2), (3, 2, 2), (5, 4, 0)]
i i
N( t matching_blocksR R R
R R R0 R R6 t _do_check_consistencyR5 ( R< R* ( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyt get_matching_blocks s "+ N( t __name__t
__module__t __doc__t TrueR? R R; R@ ( ( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyR6 s (
t
__future__R R R9 t bzrlib.traceR t __all__R R R0 R5 R: R6 ( ( ( s; /usr/lib/python2.7/dist-packages/bzrlib/_patiencediff_py.pyt <module> s N >
Copyright © 2017 || Recoded By Mr.Bumblebee