Changeset - 923db690b56f
Parent rev.
Child rev.
[Not reviewed]
default
0 2 0
Mads Kiilerich - 9 years ago 2016-09-06 00:51:18
madski@unity3d.com
helpers: inline changeset hash markup in urlify_text
2 files changed with 12 insertions and 24 deletions:
kallithea/lib/helpers.py
11
23
kallithea/tests/other/test_libs.py
1
1
0 comments (0 inline, 0 general)
kallithea/lib/helpers.py
➞
Show inline comments
 
@@ -1157,280 +1157,268 @@ def repo_link(groups_and_repos):
 
def fancy_file_stats(stats):
 
    """
 
    Displays a fancy two colored bar for number of added/deleted
 
    lines of code on file
 

			




	
	
	
		
 
    :param stats: two element list of added/deleted lines of code

			




	
	
	
		
 
    """

			




	
	
	
		
 
    from kallithea.lib.diffs import NEW_FILENODE, DEL_FILENODE, \

			




	
	
	
		
 
        MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE

			




	
	
	
		
 

			




	
	
	
		
 
    def cgen(l_type, a_v, d_v):

			




	
	
	
		
 
        mapping = {'tr': 'top-right-rounded-corner-mid',

			




	
	
	
		
 
                   'tl': 'top-left-rounded-corner-mid',

			




	
	
	
		
 
                   'br': 'bottom-right-rounded-corner-mid',

			




	
	
	
		
 
                   'bl': 'bottom-left-rounded-corner-mid'}

			




	
	
	
		
 
        map_getter = lambda x: mapping[x]

			




	
	
	
		
 

			




	
	
	
		
 
        if l_type == 'a' and d_v:

			




	
	
	
		
 
            #case when added and deleted are present

			




	
	
	
		
 
            return ' '.join(map(map_getter, ['tl', 'bl']))

			




	
	
	
		
 

			




	
	
	
		
 
        if l_type == 'a' and not d_v:

			




	
	
	
		
 
            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

			




	
	
	
		
 

			




	
	
	
		
 
        if l_type == 'd' and a_v:

			




	
	
	
		
 
            return ' '.join(map(map_getter, ['tr', 'br']))

			




	
	
	
		
 

			




	
	
	
		
 
        if l_type == 'd' and not a_v:

			




	
	
	
		
 
            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

			




	
	
	
		
 

			




	
	
	
		
 
    a, d = stats['added'], stats['deleted']

			




	
	
	
		
 
    width = 100

			




	
	
	
		
 

			




	
	
	
		
 
    if stats['binary']:

			




	
	
	
		
 
        #binary mode

			




	
	
	
		
 
        lbl = ''

			




	
	
	
		
 
        bin_op = 1

			




	
	
	
		
 

			




	
	
	
		
 
        if BIN_FILENODE in stats['ops']:

			




	
	
	
		
 
            lbl = 'bin+'

			




	
	
	
		
 

			




	
	
	
		
 
        if NEW_FILENODE in stats['ops']:

			




	
	
	
		
 
            lbl += _('new file')

			




	
	
	
		
 
            bin_op = NEW_FILENODE

			




	
	
	
		
 
        elif MOD_FILENODE in stats['ops']:

			




	
	
	
		
 
            lbl += _('mod')

			




	
	
	
		
 
            bin_op = MOD_FILENODE

			




	
	
	
		
 
        elif DEL_FILENODE in stats['ops']:

			




	
	
	
		
 
            lbl += _('del')

			




	
	
	
		
 
            bin_op = DEL_FILENODE

			




	
	
	
		
 
        elif RENAMED_FILENODE in stats['ops']:

			




	
	
	
		
 
            lbl += _('rename')

			




	
	
	
		
 
            bin_op = RENAMED_FILENODE

			




	
	
	
		
 

			




	
	
	
		
 
        #chmod can go with other operations

			




	
	
	
		
 
        if CHMOD_FILENODE in stats['ops']:

			




	
	
	
		
 
            _org_lbl = _('chmod')

			




	
	
	
		
 
            lbl += _org_lbl if lbl.endswith('+') else '+%s' % _org_lbl

			




	
	
	
		
 

			




	
	
	
		
 
        #import ipdb;ipdb.set_trace()

			




	
	
	
		
 
        b_d = '<div class="bin bin%s %s" style="width:100%%">%s</div>' % (bin_op, cgen('a', a_v='', d_v=0), lbl)

			




	
	
	
		
 
        b_a = '<div class="bin bin1" style="width:0%"></div>'

			




	
	
	
		
 
        return literal('<div style="width:%spx">%s%s</div>' % (width, b_a, b_d))

			




	
	
	
		
 

			




	
	
	
		
 
    t = stats['added'] + stats['deleted']

			




	
	
	
		
 
    unit = float(width) / (t or 1)

			




	
	
	
		
 

			




	
	
	
		
 
    # needs > 9% of width to be visible or 0 to be hidden

			




	
	
	
		
 
    a_p = max(9, unit * a) if a > 0 else 0

			




	
	
	
		
 
    d_p = max(9, unit * d) if d > 0 else 0

			




	
	
	
		
 
    p_sum = a_p + d_p

			




	
	
	
		
 

			




	
	
	
		
 
    if p_sum > width:

			




	
	
	
		
 
        #adjust the percentage to be == 100% since we adjusted to 9

			




	
	
	
		
 
        if a_p > d_p:

			




	
	
	
		
 
            a_p = a_p - (p_sum - width)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            d_p = d_p - (p_sum - width)

			




	
	
	
		
 

			




	
	
	
		
 
    a_v = a if a > 0 else ''

			




	
	
	
		
 
    d_v = d if d > 0 else ''

			




	
	
	
		
 

			




	
	
	
		
 
    d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (

			




	
	
	
		
 
        cgen('a', a_v, d_v), a_p, a_v

			




	
	
	
		
 
    )

			




	
	
	
		
 
    d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (

			




	
	
	
		
 
        cgen('d', a_v, d_v), d_p, d_v

			




	
	
	
		
 
    )

			




	
	
	
		
 
    return literal('<div style="width:%spx">%s%s</div>' % (width, d_a, d_d))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
_URLIFY_RE = re.compile(r'''

			




	
	
	
		
 
# URL markup

			




	
	
	
		
 
(?P<url>%s) |

			




	
	
	
		
 
# @mention markup

			




	
	
	
		
 
(?P<mention>%s) |

			




	
	
	
		
 
# Changeset hash markup

			




	
	
	
		
 
(?<!\w|[-_])

			




	
	
	
		
 
  (?P<hash>[0-9a-f]{12,40})

			




	
	
	
		
 
(?!\w|[-_]) |

			




	
	
	
		
 
# "Stylize" markup

			




	
	
	
		
 
\[see\ \=&gt;\ *(?P<seen>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

			




	
	
	
		
 
\[license\ \=&gt;\ *(?P<license>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

			




	
	
	
		
 
\[(?P<tagtype>requires|recommends|conflicts|base)\ \=&gt;\ *(?P<tagvalue>[a-zA-Z0-9\-\/]*)\] |

			




	
	
	
		
 
\[(?:lang|language)\ \=&gt;\ *(?P<lang>[a-zA-Z\-\/\#\+]*)\] |

			




	
	
	
		
 
\[(?P<tag>[a-z]+)\]

			




	
	
	
		
 
''' % (url_re.pattern, MENTIONS_REGEX.pattern),

			




	
	
	
		
 
    re.VERBOSE | re.MULTILINE | re.IGNORECASE)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_text(s, repo_name=None, link_=None, truncate=None, stylize=False, truncatef=truncate):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Parses given text message and make literal html with markup.

			




	
	
	
		
 
    The text will be truncated to the specified length.

			




	
	
	
		
 
    Hashes are turned into changeset links to specified repository.

			




	
	
	
		
 
    URLs links to what they say.

			




	
	
	
		
 
    Issues are linked to given issue-server.

			




	
	
	
		
 
    If link_ is provided, all text not already linking somewhere will link there.

			




	
	
	
		
 
    """

			




	
	
	
		
 

			




	
	
	
		
 
    def _replace(match_obj):

			




	
	
	
		
 
        url = match_obj.group('url')

			




	
	
	
		
 
        if url is not None:

			




	
	
	
		
 
            return '<a href="%(url)s">%(url)s</a>' % {'url': url}

			




	
	
	
		
 
        mention = match_obj.group('mention')

			




	
	
	
		
 
        if mention is not None:

			




	
	
	
		
 
            return '<b>%s</b>' % mention

			




	
	
	
		
 
        hash_ = match_obj.group('hash')

			




	
	
	
		
 
        if hash_ is not None and repo_name is not None:

			




	
	
	
		
 
            from pylons import url  # doh, we need to re-import url to mock it later

			




	
	
	
		
 
            return '<a class="revision-link" href="%(url)s">%(hash)s</a>' % {

			




	
	
	
		
 
                 'url': url('changeset_home', repo_name=repo_name, revision=hash_),

			




	
	
	
		
 
                 'hash': hash_,

			




	
	
	
		
 
                }

			




	
	
	
		
 
        if stylize:

			




	
	
	
		
 
            seen = match_obj.group('seen')

			




	
	
	
		
 
            if seen:

			




	
	
	
		
 
                return '<div class="metatag" tag="see">see =&gt; %s</div>' % seen

			




	
	
	
		
 
            license = match_obj.group('license')

			




	
	
	
		
 
            if license:

			




	
	
	
		
 
                return '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/%s">%s</a></div>' % (license, license)

			




	
	
	
		
 
            tagtype = match_obj.group('tagtype')

			




	
	
	
		
 
            if tagtype:

			




	
	
	
		
 
                tagvalue = match_obj.group('tagvalue')

			




	
	
	
		
 
                return '<div class="metatag" tag="%s">%s =&gt; <a href="/%s">%s</a></div>' % (tagtype, tagtype, tagvalue, tagvalue)

			




	
	
	
		
 
            lang = match_obj.group('lang')

			




	
	
	
		
 
            if lang:

			




	
	
	
		
 
                return '<div class="metatag" tag="lang">%s</div>' % lang

			




	
	
	
		
 
            tag = match_obj.group('tag')

			




	
	
	
		
 
            if tag:

			




	
	
	
		
 
                return '<div class="metatag" tag="%s">%s</div>' % (tag, tag)

			




	
	
	
		
 
        return match_obj.group(0)

			




	
	
	
		
 

			




	
	
	
		
 
    def _urlify(s):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Extract urls from text and make html links out of them

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return _URLIFY_RE.sub(_replace, s)

			




	
	
	
		
 

			




	
	
	
		
 
    if truncate is None:

			




	
	
	
		
 
        s = s.rstrip()

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        s = truncatef(s, truncate, whole_word=True)

			




	
	
	
		
 
    s = html_escape(s)

			




	
	
	
		
 
    if repo_name is not None:

			




	
	
	
		
 
        s = urlify_changesets(s, repo_name)

			




	
	
	
		
 
    s = _urlify(s)

			




	
	
	
		
 
    if repo_name is not None:

			




	
	
	
		
 
        s = urlify_issues(s, repo_name, link_)

			




	
	
	
		
 
    s = s.replace('\r\n', '<br/>').replace('\n', '<br/>')

			




	
	
	
		
 
    return literal(s)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _urlify_changeset_replace_f(repo_name):

			




	
	
	
		
 
    from pylons import url  # doh, we need to re-import url to mock it later

			




	
	
	
		
 
    def urlify_changeset_replace(match_obj):

			




	
	
	
		
 
        rev = match_obj.group(0)

			




	
	
	
		
 
        return '<a class="revision-link" href="%(url)s">%(rev)s</a>' % {

			




	
	
	
		
 
         'url': url('changeset_home', repo_name=repo_name, revision=rev),

			




	
	
	
		
 
         'rev': rev,

			




	
	
	
		
 
        }

			




	
	
	
		
 
    return urlify_changeset_replace

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
urilify_changeset_re = r'(?:^|(?<=[\s(),]))([0-9a-fA-F]{12,40})(?=$|\s|[.,:()])'

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_changesets(text_, repo_name):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Extract revision ids from changeset and make link from them

			




	
	
	
		
 
    """

			




	
	
	
		
 
    urlify_changeset_replace = _urlify_changeset_replace_f(repo_name)

			




	
	
	
		
 
    return re.sub(urilify_changeset_re, urlify_changeset_replace, text_)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def linkify_others(t, l):

			




	
	
	
		
 
    """Add a default link to html with links.

			




	
	
	
		
 
    HTML doesn't allow nesting of links, so the outer link must be broken up

			




	
	
	
		
 
    in pieces and give space for other links.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    urls = re.compile(r'(\<a.*?\<\/a\>)',)

			




	
	
	
		
 
    links = []

			




	
	
	
		
 
    for e in urls.split(t):

			




	
	
	
		
 
        if not urls.match(e):

			




	
	
	
		
 
            links.append('<a class="message-link" href="%s">%s</a>' % (l, e))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            links.append(e)

			




	
	
	
		
 

			




	
	
	
		
 
    return ''.join(links)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _urlify_issues_replace_f(repo_name, ISSUE_SERVER_LNK, ISSUE_PREFIX):

			




	
	
	
		
 
    def urlify_issues_replace(match_obj):

			




	
	
	
		
 
        pref = ''

			




	
	
	
		
 
        if match_obj.group().startswith(' '):

			




	
	
	
		
 
            pref = ' '

			




	
	
	
		
 

			




	
	
	
		
 
        issue_id = ''.join(match_obj.groups())

			




	
	
	
		
 
        issue_url = ISSUE_SERVER_LNK.replace('{id}', issue_id)

			




	
	
	
		
 
        issue_url = issue_url.replace('{repo}', repo_name)

			




	
	
	
		
 
        issue_url = issue_url.replace('{repo_name}', repo_name.split(URL_SEP)[-1])

			




	
	
	
		
 

			




	
	
	
		
 
        return (

			




	
	
	
		
 
            '%(pref)s<a class="%(cls)s" href="%(url)s">'

			




	
	
	
		
 
            '%(issue-prefix)s%(id-repr)s'

			




	
	
	
		
 
            '</a>'

			




	
	
	
		
 
            ) % {

			




	
	
	
		
 
             'pref': pref,

			




	
	
	
		
 
             'cls': 'issue-tracker-link',

			




	
	
	
		
 
             'url': issue_url,

			




	
	
	
		
 
             'id-repr': issue_id,

			




	
	
	
		
 
             'issue-prefix': ISSUE_PREFIX,

			




	
	
	
		
 
             'serv': ISSUE_SERVER_LNK,

			




	
	
	
		
 
            }

			




	
	
	
		
 
    return urlify_issues_replace

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_issues(newtext, repo_name, link_=None):

			




	
	
	
		
 
    from kallithea import CONFIG as conf

			




	
	
	
		
 

			




	
	
	
		
 
    # allow multiple issue servers to be used

			




	
	
	
		
 
    valid_indices = [

			




	
	
	
		
 
        x.group(1)

			




	
	
	
		
 
        for x in map(lambda x: re.match(r'issue_pat(.*)', x), conf.keys())

			




	
	
	
		
 
        if x and 'issue_server_link%s' % x.group(1) in conf

			




	
	
	
		
 
        and 'issue_prefix%s' % x.group(1) in conf

			




	
	
	
		
 
    ]

			




	
	
	
		
 

			




	
	
	
		
 
    if valid_indices:

			




	
	
	
		
 
        log.debug('found issue server suffixes `%s` during valuation of: %s',

			




	
	
	
		
 
                  ','.join(valid_indices), newtext)

			




	
	
	
		
 

			




	
	
	
		
 
    for pattern_index in valid_indices:

			




	
	
	
		
 
        ISSUE_PATTERN = conf.get('issue_pat%s' % pattern_index)

			




	
	
	
		
 
        ISSUE_SERVER_LNK = conf.get('issue_server_link%s' % pattern_index)

			




	
	
	
		
 
        ISSUE_PREFIX = conf.get('issue_prefix%s' % pattern_index)

			




	
	
	
		
 

			




	
	
	
		
 
        log.debug('pattern suffix `%s` PAT:%s SERVER_LINK:%s PREFIX:%s',

			




	
	
	
		
 
                  pattern_index, ISSUE_PATTERN, ISSUE_SERVER_LNK,

			




	
	
	
		
 
                  ISSUE_PREFIX)

			




	
	
	
		
 

			




	
	
	
		
 
        URL_PAT = re.compile(ISSUE_PATTERN)

			




	
	
	
		
 

			




	
	
	
		
 
        urlify_issues_replace = _urlify_issues_replace_f(repo_name, ISSUE_SERVER_LNK, ISSUE_PREFIX)

			




	
	
	
		
 
        newtext = URL_PAT.sub(urlify_issues_replace, newtext)

			




	
	
	
		
 
        log.debug('processed prefix:`%s` => %s', pattern_index, newtext)

			




	
	
	
		
 

			




	
	
	
		
 
    # if we actually did something above

			




	
	
	
		
 
    if link_:

			




	
	
	
		
 
        # wrap not links into final link => link_

			




	
	
	
		
 
        newtext = linkify_others(newtext, link_)

			




	
	
	
		
 
    return newtext

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def render_w_mentions(source, repo_name=None):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Render plain text with revision hashes and issue references urlified

			




	
	
	
		
 
    and with @mention highlighting.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    s = safe_unicode(source)

			




	
	
	
		
 
    s = urlify_text(s, repo_name=repo_name)

			




	
	
	
		
 
    return literal('<div class="formatted-fixed">%s</div>' % s)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def short_ref(ref_type, ref_name):

			




	
	
	
		
 
    if ref_type == 'rev':

			




	
	
	
		
 
        return short_id(ref_name)

			




	
	
	
		
 
    return ref_name

			




	
	
	
		
 

			




	
	
	
		
 
def link_to_ref(repo_name, ref_type, ref_name, rev=None):

			




	
	
	
		
 
    """

			




        

    


    
    

    

        

                

                    kallithea/tests/other/test_libs.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -220,176 +220,176 @@ class TestLibs(TestController):

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                    from pylons import url

			




	
	
	
		
 
                    assert url.current() == 'https://example.com'

			




	
	
	
		
 
                    grav = gravatar_url(email_address='test@example.com', size=24)

			




	
	
	
		
 
                    assert grav == 'http://example.com/test@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                grav = gravatar_url(email_address='test@example.com', size=24)

			




	
	
	
		
 
                assert grav == 'http://example.com/test@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{md5email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://example.com/%s' % (_md5(em))

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://example.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'https://example.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('tmpl,repo_name,overrides,prefix,expected', [

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '/prefix', 'http://vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix', 'http://user@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix', 'http://username@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix/', 'http://user@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix/', 'http://username@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {}, '', 'http://vps1:8000/_23'),

			




	
	
	
		
 
        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

			




	
	
	
		
 
        ('http://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

			




	
	
	
		
 
        ('http://{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://vps1:8000/_23'),

			




	
	
	
		
 
        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://username@proxy1.example.com/group/repo1'),

			




	
	
	
		
 
        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.example.com/group/repo1'),

			




	
	
	
		
 
        ('https://proxy1.example.com/{user}/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://proxy1.example.com/username/group/repo1'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_clone_url_generator(self, tmpl, repo_name, overrides, prefix, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import get_clone_url

			




	
	
	
		
 
        clone_url = get_clone_url(uri_tmpl=tmpl, qualified_home_url='http://vps1:8000'+prefix,

			




	
	
	
		
 
                                  repo_name=repo_name, repo_id=23, **overrides)

			




	
	
	
		
 
        assert clone_url == expected

			




	
	
	
		
 

			




	
	
	
		
 
    def _quick_url(self, text, tmpl="""<a class="revision-link" href="%s">%s</a>""", url_=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Changes `some text url[foo]` => `some text <a href="/">foo</a>

			




	
	
	
		
 

			




	
	
	
		
 
        :param text:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        import re

			




	
	
	
		
 
        # quickly change expected url[] into a link

			




	
	
	
		
 
        URL_PAT = re.compile(r'(?:url\[)(.+?)(?:\])')

			




	
	
	
		
 

			




	
	
	
		
 
        def url_func(match_obj):

			




	
	
	
		
 
            _url = match_obj.groups()[0]

			




	
	
	
		
 
            return tmpl % (url_ or '/some-url', _url)

			




	
	
	
		
 
        return URL_PAT.sub(url_func, text)

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('sample,expected', [

			




	
	
	
		
 
      ("",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",

			




	
	
	
		
 
       """git-svn-id: <a href="https://svn.apache.org/repos/asf/libcloud/trunk@1441655">https://svn.apache.org/repos/asf/libcloud/trunk@1441655</a> 13f79535-47bb-0310-9956-ffa450edef68"""),

			




	
	
	
		
 
      ("from rev 000000000000",

			




	
	
	
		
 
       """from rev url[000000000000]"""),

			




	
	
	
		
 
      ("from rev 000000000000123123 also rev 000000000000",

			




	
	
	
		
 
       """from rev url[000000000000123123] also rev url[000000000000]"""),

			




	
	
	
		
 
      ("this should-000 00",

			




	
	
	
		
 
       """this should-000 00"""),

			




	
	
	
		
 
      ("longtextffffffffff rev 123123123123",

			




	
	
	
		
 
       """longtextffffffffff rev url[123123123123]"""),

			




	
	
	
		
 
      ("rev ffffffffffffffffffffffffffffffffffffffffffffffffff",

			




	
	
	
		
 
       """rev ffffffffffffffffffffffffffffffffffffffffffffffffff"""),

			




	
	
	
		
 
      ("ffffffffffff some text traalaa",

			




	
	
	
		
 
       """url[ffffffffffff] some text traalaa"""),

			




	
	
	
		
 
       ("""Multi line

			




	
	
	
		
 
       123123123123

			




	
	
	
		
 
       some text 123123123123

			




	
	
	
		
 
       sometimes !

			




	
	
	
		
 
       """,

			




	
	
	
		
 
       """Multi line<br/>"""

			




	
	
	
		
 
       """       url[123123123123]<br/>"""

			




	
	
	
		
 
       """       some text url[123123123123]<br/>"""

			




	
	
	
		
 
       """       sometimes !"""),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_changesets(self, sample, expected):

			




	
	
	
		
 
    def test_urlify_text(self, sample, expected):

			




	
	
	
		
 
        def fake_url(self, *args, **kwargs):

			




	
	
	
		
 
            return '/some-url'

			




	
	
	
		
 

			




	
	
	
		
 
        expected = self._quick_url(expected)

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
            assert urlify_text(sample, 'repo_name') == expected

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('sample,expected,url_', [

			




	
	
	
		
 
      ("",

			




	
	
	
		
 
       "",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("https://svn.apache.org/repos",

			




	
	
	
		
 
       """url[https://svn.apache.org/repos]""",

			




	
	
	
		
 
       "https://svn.apache.org/repos"),

			




	
	
	
		
 
      ("http://svn.apache.org/repos",

			




	
	
	
		
 
       """url[http://svn.apache.org/repos]""",

			




	
	
	
		
 
       "http://svn.apache.org/repos"),

			




	
	
	
		
 
      ("from rev a also rev http://google.com",

			




	
	
	
		
 
       """from rev a also rev url[http://google.com]""",

			




	
	
	
		
 
       "http://google.com"),

			




	
	
	
		
 
      ("http://imgur.com/foo.gif inline http://imgur.com/foo.gif ending http://imgur.com/foo.gif",

			




	
	
	
		
 
       """url[http://imgur.com/foo.gif] inline url[http://imgur.com/foo.gif] ending url[http://imgur.com/foo.gif]""",

			




	
	
	
		
 
       "http://imgur.com/foo.gif"),

			




	
	
	
		
 
      ("""Multi line

			




	
	
	
		
 
       https://foo.bar.example.com

			




	
	
	
		
 
       some text lalala""",

			




	
	
	
		
 
       """Multi line<br/>"""

			




	
	
	
		
 
       """       url[https://foo.bar.example.com]<br/>"""

			




	
	
	
		
 
       """       some text lalala""",

			




	
	
	
		
 
       "https://foo.bar.example.com"),

			




	
	
	
		
 
      ("@mention @someone",

			




	
	
	
		
 
       """<b>@mention</b> <b>@someone</b>""",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("deadbeefcafe 123412341234",

			




	
	
	
		
 
       """<a class="revision-link" href="/repo_name/changeset/deadbeefcafe">deadbeefcafe</a> <a class="revision-link" href="/repo_name/changeset/123412341234">123412341234</a>""",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      # tags are covered by test_tag_extractor

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_test(self, sample, expected, url_):

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        expected = self._quick_url(expected,

			




	
	
	
		
 
                                   tmpl="""<a href="%s">%s</a>""", url_=url_)

			




	
	
	
		
 
        assert urlify_text(sample, 'repo_name', stylize=True) == expected

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('sample,expected', [

			




	
	
	
		
 
      ("deadbeefcafe @mention, and http://foo.bar/ yo",

			




	
	
	
		
 
       """<a class="message-link" href="#the-link"></a>"""

			




	
	
	
		
 
       """<a class="revision-link" href="/repo_name/changeset/deadbeefcafe">deadbeefcafe</a>"""

			




	
	
	
		
 
       """<a class="message-link" href="#the-link"> <b>@mention</b>, and </a>"""

			




	
	
	
		
 
       """<a href="http://foo.bar/">http://foo.bar/</a>"""

			




	
	
	
		
 
       """<a class="message-link" href="#the-link"> yo</a>"""),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_link(self, sample, expected):

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        assert urlify_text(sample, 'repo_name', link_='#the-link') == expected

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('test,expected', [

			




	
	
	
		
 
      ("", None),

			




	
	
	
		
 
      ("/_2", '2'),

			




	
	
	
		
 
      ("_2", '2'),

			




	
	
	
		
 
      ("/_2/", '2'),

			




	
	
	
		
 
      ("_2/", '2'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_21", '21'),

			




	
	
	
		
 
      ("_21", '21'),

			




	
	
	
		
 
      ("/_21/", '21'),

			




	
	
	
		
 
      ("_21/", '21'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_21/foobar", '21'),

			




	
	
	
		
 
      ("_21/121", '21'),

			




	
	
	
		
 
      ("/_21/_12", '21'),

			




	
	
	
		
 
      ("_21/prefix/foo", '21'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_get_repo_by_id(self, test, expected):

			




	
	
	
		
 
        from kallithea.lib.utils import _extract_id_from_repo_name

			




	
	
	
		
 
        _test = _extract_id_from_repo_name(test)

			




	
	
	
		
 
        assert _test == expected, 'url:%s, got:`%s` expected: `%s`' % (test, _test, expected)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.