Changeset - e5a7f8f41370
Parent rev.
Child rev.
[Not reviewed]
default
0 3 0
Thomas De Schampheleire - 8 years ago 2018-02-16 22:30:51
thomas.de_schampheleire@nokia.com
issues: backout special whitespace handling

This is essentially a backout of commit 32e1e0745d3c.

That commit checked for whitespace at the beginning of the matched issue
reference, and explicitly retained it in the resulting link text.

The way this was handled is not only suboptimal, e.g. a set of 4 spaces
would still be reduced to 1, but is also not actually necessary: if
whitespace before the issue reference is not required, then it does not need
to be specified in the issue pattern, and if it _is_ required, then a
positive lookbehind assertion can be used instead.
3 files changed with 20 insertions and 7 deletions:
kallithea/lib/helpers.py
1
3
kallithea/lib/paster_commands/template.ini.mako
3
kallithea/tests/other/test_libs.py
16
4
0 comments (0 inline, 0 general)
kallithea/lib/helpers.py
➞
Show inline comments
 
@@ -1063,203 +1063,201 @@ def urlify_text(s, repo_name=None, link_
 
            if license:
 
                return '<div class="label label-meta" data-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="label label-meta" data-tag="%s">%s =&gt; <a href="/%s">%s</a></div>' % (tagtype, tagtype, tagvalue, tagvalue)
 
            lang = match_obj.group('lang')
 
            if lang:
 
                return '<div class="label label-meta" data-tag="lang">%s</div>' % lang
 
            tag = match_obj.group('tag')
 
            if tag:
 
                return '<div class="label label-meta" data-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)

			




	
	
	
		
 
    s = _urlify(s)

			




	
	
	
		
 
    if repo_name is not None:

			




	
	
	
		
 
        s = urlify_issues(s, repo_name)

			




	
	
	
		
 
    if link_ is not None:

			




	
	
	
		
 
        # make href around everything that isn't a href already

			




	
	
	
		
 
        s = linkify_others(s, link_)

			




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

			




	
	
	
		
 
    # Turn HTML5 into more valid HTML4 as required by some mail readers.

			




	
	
	
		
 
    # (This is not done in one step in html_escape, because character codes like

			




	
	
	
		
 
    # &#123; risk to be seen as an issue reference due to the presence of '#'.)

			




	
	
	
		
 
    s = s.replace("&apos;", "&#39;")

			




	
	
	
		
 
    return literal(s)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
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 e.strip() and not urls.match(e):

			




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

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            links.append(e)

			




	
	
	
		
 

			




	
	
	
		
 
    return ''.join(links)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
# Global variable that will hold the actual urlify_issues function body.

			




	
	
	
		
 
# Will be set on first use when the global configuration has been read.

			




	
	
	
		
 
_urlify_issues_f = None

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_issues(newtext, repo_name):

			




	
	
	
		
 
    """Urlify issue references according to .ini configuration"""

			




	
	
	
		
 
    global _urlify_issues_f

			




	
	
	
		
 
    if _urlify_issues_f is None:

			




	
	
	
		
 
        from kallithea import CONFIG

			




	
	
	
		
 
        from kallithea.model.db import URL_SEP

			




	
	
	
		
 
        assert CONFIG['sqlalchemy.url'] # make sure config has been loaded

			




	
	
	
		
 

			




	
	
	
		
 
        # Build chain of urlify functions, starting with not doing any transformation

			




	
	
	
		
 
        tmp_urlify_issues_f = lambda s: s

			




	
	
	
		
 

			




	
	
	
		
 
        issue_pat_re = re.compile(r'issue_pat(.*)')

			




	
	
	
		
 
        for k in CONFIG.keys():

			




	
	
	
		
 
            # Find all issue_pat* settings that also have corresponding server_link and prefix configuration

			




	
	
	
		
 
            m = issue_pat_re.match(k)

			




	
	
	
		
 
            if m is None:

			




	
	
	
		
 
                continue

			




	
	
	
		
 
            suffix = m.group(1)

			




	
	
	
		
 
            issue_pat = CONFIG.get(k)

			




	
	
	
		
 
            issue_server_link = CONFIG.get('issue_server_link%s' % suffix)

			




	
	
	
		
 
            issue_prefix = CONFIG.get('issue_prefix%s' % suffix)

			




	
	
	
		
 
            if not issue_pat or not issue_server_link or issue_prefix is None: # issue_prefix can be empty but should be present

			




	
	
	
		
 
                log.error('skipping incomplete issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

			




	
	
	
		
 
                continue

			




	
	
	
		
 

			




	
	
	
		
 
            # Wrap tmp_urlify_issues_f with substitution of this pattern, while making sure all loop variables (and compiled regexpes) are bound

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                issue_re = re.compile(issue_pat)

			




	
	
	
		
 
            except re.error as e:

			




	
	
	
		
 
                log.error('skipping invalid issue pattern %r: %r -> %r %r. Error: %s', suffix, issue_pat, issue_server_link, issue_prefix, str(e))

			




	
	
	
		
 
                continue

			




	
	
	
		
 

			




	
	
	
		
 
            log.debug('issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

			




	
	
	
		
 

			




	
	
	
		
 
            def issues_replace(match_obj,

			




	
	
	
		
 
                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

			




	
	
	
		
 
                leadingspace = ' ' if match_obj.group().startswith(' ') else ''

			




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

			




	
	
	
		
 
                issue_url = issue_server_link.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 (

			




	
	
	
		
 
                    '%(leadingspace)s<a class="issue-tracker-link" href="%(url)s">'

			




	
	
	
		
 
                    '<a class="issue-tracker-link" href="%(url)s">'

			




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

			




	
	
	
		
 
                    '</a>'

			




	
	
	
		
 
                    ) % {

			




	
	
	
		
 
                     'leadingspace': leadingspace,

			




	
	
	
		
 
                     'url': issue_url,

			




	
	
	
		
 
                     'id-repr': issue_id,

			




	
	
	
		
 
                     'issue-prefix': issue_prefix,

			




	
	
	
		
 
                     'serv': issue_server_link,

			




	
	
	
		
 
                    }

			




	
	
	
		
 
            tmp_urlify_issues_f = (lambda s,

			




	
	
	
		
 
                                          issue_re=issue_re, issues_replace=issues_replace, chain_f=tmp_urlify_issues_f:

			




	
	
	
		
 
                                   issue_re.sub(issues_replace, chain_f(s)))

			




	
	
	
		
 

			




	
	
	
		
 
        # Set tmp function globally - atomically

			




	
	
	
		
 
        _urlify_issues_f = tmp_urlify_issues_f

			




	
	
	
		
 

			




	
	
	
		
 
    return _urlify_issues_f(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):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Return full markup for a href to changeset_home for a changeset.

			




	
	
	
		
 
    If ref_type is branch it will link to changelog.

			




	
	
	
		
 
    ref_name is shortened if ref_type is 'rev'.

			




	
	
	
		
 
    if rev is specified show it too, explicitly linking to that revision.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    txt = short_ref(ref_type, ref_name)

			




	
	
	
		
 
    if ref_type == 'branch':

			




	
	
	
		
 
        u = url('changelog_home', repo_name=repo_name, branch=ref_name)

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        u = url('changeset_home', repo_name=repo_name, revision=ref_name)

			




	
	
	
		
 
    l = link_to(repo_name + '#' + txt, u)

			




	
	
	
		
 
    if rev and ref_type != 'rev':

			




	
	
	
		
 
        l = literal('%s (%s)' % (l, link_to(short_id(rev), url('changeset_home', repo_name=repo_name, revision=rev))))

			




	
	
	
		
 
    return l

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def changeset_status(repo, revision):

			




	
	
	
		
 
    from kallithea.model.changeset_status import ChangesetStatusModel

			




	
	
	
		
 
    return ChangesetStatusModel().get_status(repo, revision)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def changeset_status_lbl(changeset_status):

			




	
	
	
		
 
    from kallithea.model.db import ChangesetStatus

			




	
	
	
		
 
    return ChangesetStatus.get_status_lbl(changeset_status)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_permission_name(key):

			




	
	
	
		
 
    from kallithea.model.db import Permission

			




	
	
	
		
 
    return dict(Permission.PERMS).get(key)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def journal_filter_help():

			




	
	
	
		
 
    return _(textwrap.dedent('''

			




	
	
	
		
 
        Example filter terms:

			




	
	
	
		
 
            repository:vcs

			




	
	
	
		
 
            username:developer

			




	
	
	
		
 
            action:*push*

			




	
	
	
		
 
            ip:127.0.0.1

			




	
	
	
		
 
            date:20120101

			




	
	
	
		
 
            date:[20120101100000 TO 20120102]

			




	
	
	
		
 

			




	
	
	
		
 
        Generate wildcards using '*' character:

			




	
	
	
		
 
            "repository:vcs*" - search everything starting with 'vcs'

			




	
	
	
		
 
            "repository:*vcs*" - search for repository containing 'vcs'

			




	
	
	
		
 

			




	
	
	
		
 
        Optional AND / OR operators in queries

			




	
	
	
		
 
            "repository:vcs OR repository:test"

			




	
	
	
		
 
            "username:test AND repository:test*"

			




	
	
	
		
 
    '''))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def not_mapped_error(repo_name):

			




	
	
	
		
 
    flash(_('%s repository is not mapped to db perhaps'

			




	
	
	
		
 
            ' it was created or renamed from the filesystem'

			




	
	
	
		
 
            ' please run the application again'

			




	
	
	
		
 
            ' in order to rescan repositories') % repo_name, category='error')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ip_range(ip_addr):

			




	
	
	
		
 
    from kallithea.model.db import UserIpMap

			




	
	
	
		
 
    s, e = UserIpMap._get_ip_range(ip_addr)

			




	
	
	
		
 
    return '%s - %s' % (s, e)

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/lib/paster_commands/template.ini.mako
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -174,192 +174,195 @@ cheaper-step = 1

			




	
	
	
		
 
<%text>## middleware for hosting the WSGI application under a URL prefix</%text>

			




	
	
	
		
 
#[filter:proxy-prefix]

			




	
	
	
		
 
#use = egg:PasteDeploy#prefix

			




	
	
	
		
 
#prefix = /<your-prefix>

			




	
	
	
		
 

			




	
	
	
		
 
[app:main]

			




	
	
	
		
 
use = egg:kallithea

			




	
	
	
		
 
<%text>## enable proxy prefix middleware</%text>

			




	
	
	
		
 
#filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
full_stack = true

			




	
	
	
		
 
static_files = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Internationalization (see setup documentation for details)</%text>

			




	
	
	
		
 
<%text>## By default, the language requested by the browser is used if available.</%text>

			




	
	
	
		
 
#i18n.enable = false

			




	
	
	
		
 
<%text>## Fallback language, empty for English (valid values are the names of subdirectories in kallithea/i18n):</%text>

			




	
	
	
		
 
i18n.lang =

			




	
	
	
		
 

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## perform a full repository scan on each server start, this should be</%text>

			




	
	
	
		
 
<%text>## set to false after first startup, to allow faster server restarts.</%text>

			




	
	
	
		
 
initial_repo_scan = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## uncomment and set this path to use archive download cache</%text>

			




	
	
	
		
 
archive_cache_dir = %(here)s/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## change this to unique ID for security</%text>

			




	
	
	
		
 
app_instance_uuid = ${uuid()}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## cut off limit for large diffs (size in bytes)</%text>

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## force https in Kallithea, fixes https redirects, assumes it's always https</%text>

			




	
	
	
		
 
force_https = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## use Strict-Transport-Security headers</%text>

			




	
	
	
		
 
use_htsts = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## number of commits stats will parse on each iteration</%text>

			




	
	
	
		
 
commit_parse_limit = 25

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## path to git executable</%text>

			




	
	
	
		
 
git_path = git

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## git rev filter option, --all is the default filter, if you need to</%text>

			




	
	
	
		
 
<%text>## hide all refs in changelog switch this to --branches --tags</%text>

			




	
	
	
		
 
#git_rev_filter = --branches --tags

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## RSS feed options</%text>

			




	
	
	
		
 
rss_cut_off_limit = 256000

			




	
	
	
		
 
rss_items_per_page = 10

			




	
	
	
		
 
rss_include_diff = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## options for showing and identifying changesets</%text>

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Canonical URL to use when creating full URLs in UI and texts.</%text>

			




	
	
	
		
 
<%text>## Useful when the site is available under different names or protocols.</%text>

			




	
	
	
		
 
<%text>## Defaults to what is provided in the WSGI environment.</%text>

			




	
	
	
		
 
#canonical_url = https://kallithea.example.com/repos

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## gist URL alias, used to create nicer urls for gist. This should be an</%text>

			




	
	
	
		
 
<%text>## url that does rewrites to _admin/gists/<gistid>.</%text>

			




	
	
	
		
 
<%text>## example: http://gist.example.com/{gistid}. Empty means use the internal</%text>

			




	
	
	
		
 
<%text>## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid></%text>

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## white list of API enabled controllers. This allows to add list of</%text>

			




	
	
	
		
 
<%text>## controllers to which access will be enabled by api_key. eg: to enable</%text>

			




	
	
	
		
 
<%text>## api access to raw_files put `FilesController:raw`, to enable access to patches</%text>

			




	
	
	
		
 
<%text>## add `ChangesetController:changeset_patch`. This list should be "," separated</%text>

			




	
	
	
		
 
<%text>## Syntax is <ControllerClass>:<function>. Check debug logs for generated names</%text>

			




	
	
	
		
 
<%text>## Recommended settings below are commented out:</%text>

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## default encoding used to convert from and to unicode</%text>

			




	
	
	
		
 
<%text>## can be also a comma separated list of encoding in case of mixed encodings</%text>

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue tracker for Kallithea (leave blank to disable, absent for default)</%text>

			




	
	
	
		
 
#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue tracking mapping for commits messages</%text>

			




	
	
	
		
 
<%text>## comment out issue_pat, issue_server, issue_prefix to enable</%text>

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## pattern to get the issues from commit messages</%text>

			




	
	
	
		
 
<%text>## default one used here is #<numbers> with a regex passive group for `#`</%text>

			




	
	
	
		
 
<%text>## {id} will be all groups matched from this pattern</%text>

			




	
	
	
		
 
<%text>## To require mandatory whitespace before the issue pattern, use:</%text>

			




	
	
	
		
 
<%text>## (?:^|(?<=\s)) before the actual pattern, and for mandatory whitespace</%text>

			




	
	
	
		
 
<%text>## behind the issue pattern, use (?:$|(?=\s)) after the actual pattern</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = #(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## server url to the issue, each {id} will be replaced with match</%text>

			




	
	
	
		
 
<%text>## fetched from the regex and {repo} is replaced with full repository name</%text>

			




	
	
	
		
 
<%text>## including groups {repo_name} is replaced with just name of repo</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## prefix to add to link to indicate it's an url</%text>

			




	
	
	
		
 
<%text>## #314 will be replaced by <issue_prefix><id></%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue_pat, issue_server_link, issue_prefix can have suffixes to specify</%text>

			




	
	
	
		
 
<%text>## multiple patterns, to other issues server, wiki or others</%text>

			




	
	
	
		
 
<%text>## below an example how to create a wiki pattern</%text>

			




	
	
	
		
 
# wiki-some-id -> https://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
#issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## alternative return HTTP header for failed authentication. Default HTTP</%text>

			




	
	
	
		
 
<%text>## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with</%text>

			




	
	
	
		
 
<%text>## handling that. Set this variable to 403 to return HTTPForbidden</%text>

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## locking return code. When repository is locked return this HTTP code. 2XX</%text>

			




	
	
	
		
 
<%text>## codes don't break the transactions while 4XX codes do</%text>

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## allows to change the repository location in settings page</%text>

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## allows to setup custom hooks in settings page</%text>

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## extra extensions for indexing, space separated and without the leading '.'.</%text>

			




	
	
	
		
 
# index.extensions =

			




	
	
	
		
 
#    gemfile

			




	
	
	
		
 
#    lock

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## extra filenames for indexing, space separated</%text>

			




	
	
	
		
 
# index.filenames =

			




	
	
	
		
 
#    .dockerignore

			




	
	
	
		
 
#    .editorconfig

			




	
	
	
		
 
#    INSTALL

			




	
	
	
		
 
#    CHANGELOG

			




	
	
	
		
 

			




	
	
	
		
 
<%text>####################################</%text>

			




	
	
	
		
 
<%text>###        CELERY CONFIG        ####</%text>

			




	
	
	
		
 
<%text>####################################</%text>

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Example: connect to the virtual host 'rabbitmqhost' on localhost as rabbitmq:</%text>

			




	
	
	
		
 
broker.url = amqp://rabbitmq:qewqew@localhost:5672/rabbitmqhost

			




	
	
	
		
 

			




	
	
	
		
 
celery.imports = kallithea.lib.celerylib.tasks

			




	
	
	
		
 
celery.accept.content = pickle

			




	
	
	
		
 
celery.result.backend = amqp

			




	
	
	
		
 
celery.result.dburi = amqp://

			




	
	
	
		
 
celery.result.serialier = json

			




	
	
	
		
 

			




	
	
	
		
 
#celery.send.task.error.emails = true

			




	
	
	
		
 
#celery.amqp.task.result.expires = 18000

			




	
	
	
		
 

			




	
	
	
		
 
celeryd.concurrency = 2

			




	
	
	
		
 
celeryd.max.tasks.per.child = 1

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## If true, tasks will never be sent to the queue, but executed locally instead.</%text>

			




	
	
	
		
 
celery.always.eager = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>####################################</%text>

			




	
	
	
		
 
<%text>###         BEAKER CACHE        ####</%text>

			




	
	
	
		
 
<%text>####################################</%text>

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.data_dir = %(here)s/data/cache/data

			




	
	
	
		
 
beaker.cache.lock_dir = %(here)s/data/cache/lock

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.regions = short_term,long_term,sql_cache_short

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.short_term.type = memory

			




	
	
	
		
 
beaker.cache.short_term.expire = 60

			




	
	
	
		
 
beaker.cache.short_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.long_term.type = memory

			




	
	
	
		
 
beaker.cache.long_term.expire = 36000

			




	
	
	
		
 
beaker.cache.long_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.sql_cache_short.type = memory

			




	
	
	
		
 
beaker.cache.sql_cache_short.expire = 10

			




	
	
	
		
 
beaker.cache.sql_cache_short.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
<%text>####################################</%text>

			




        

    


    
    

    

        

                

                    kallithea/tests/other/test_libs.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -318,208 +318,220 @@ class TestLibs(TestController):

			




	
	
	
		
 
      ("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_text(self, sample, expected):

			




	
	
	
		
 
        expected = self._quick_url(expected)

			




	
	
	
		
 
        fake_url = FakeUrlGenerator(changeset_home='/%(repo_name)s/changeset/%(revision)s')

			




	
	
	
		
 
        with mock.patch('kallithea.config.routing.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="changeset_hash" href="/repo_name/changeset/deadbeefcafe">deadbeefcafe</a> <a class="changeset_hash" href="/repo_name/changeset/123412341234">123412341234</a>""",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("We support * markup for *bold* markup of *single or multiple* words, "

			




	
	
	
		
 
       "*a bit @like http://slack.com*. "

			




	
	
	
		
 
       "The first * must come after whitespace and not be followed by whitespace, "

			




	
	
	
		
 
       "contain anything but * and newline until the next *, "

			




	
	
	
		
 
       "which must not come after whitespace "

			




	
	
	
		
 
       "and not be followed by * or alphanumerical *characters*.",

			




	
	
	
		
 
       """We support * markup for <b>*bold*</b> markup of <b>*single or multiple*</b> words, """

			




	
	
	
		
 
       """<b>*a bit <b>@like</b> <a href="http://slack.com">http://slack.com</a>*</b>. """

			




	
	
	
		
 
       """The first * must come after whitespace and not be followed by whitespace, """

			




	
	
	
		
 
       """contain anything but * and newline until the next *, """

			




	
	
	
		
 
       """which must not come after whitespace """

			




	
	
	
		
 
       """and not be followed by * or alphanumerical <b>*characters*</b>.""",

			




	
	
	
		
 
       "-"),

			




	
	
	
		
 
      ("HTML escaping: <abc> 'single' \"double\" &pointer",

			




	
	
	
		
 
       "HTML escaping: &lt;abc&gt; &#39;single&#39; &quot;double&quot; &amp;pointer",

			




	
	
	
		
 
       "-"),

			




	
	
	
		
 
      # tags are covered by test_tag_extractor

			




	
	
	
		
 
    ])

			




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

			




	
	
	
		
 
        expected = self._quick_url(expected,

			




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

			




	
	
	
		
 
        fake_url = FakeUrlGenerator(changeset_home='/%(repo_name)s/changeset/%(revision)s')

			




	
	
	
		
 
        with mock.patch('kallithea.config.routing.url', fake_url):

			




	
	
	
		
 
            from kallithea.lib.helpers import urlify_text

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('sample,expected', [

			




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

			




	
	
	
		
 
       """<a class="changeset_hash" 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):

			




	
	
	
		
 
        fake_url = FakeUrlGenerator(changeset_home='/%(repo_name)s/changeset/%(revision)s')

			




	
	
	
		
 
        with mock.patch('kallithea.config.routing.url', fake_url):

			




	
	
	
		
 
            from kallithea.lib.helpers import urlify_text

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('issue_pat,issue_server,issue_prefix,sample,expected', [

			




	
	
	
		
 
        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'issue #123 and issue#456',

			




	
	
	
		
 
            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

			




	
	
	
		
 
        # following test case shows the result of a backward incompatible change that was made: the

			




	
	
	
		
 
        # space between 'issue' and '#123' is removed, because the space is part of the pattern.

			




	
	
	
		
 
        (r'(?:\s*#)(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'issue #123 and issue#456',

			




	
	
	
		
 
            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

			




	
	
	
		
 
        # to require whitespace before the issue reference, one may be tempted to use \b...

			




	
	
	
		
 
        (r'\bPR(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'issue PR123 and issuePR456',

			




	
	
	
		
 
            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issuePR456"""),

			




	
	
	
		
 
        # following test case shows that \b does not work well in combination with '#': the expectations

			




	
	
	
		
 
        # ... but it turns out that \b does not work well in combination with '#': the expectations

			




	
	
	
		
 
        # are reversed from what is actually happening.

			




	
	
	
		
 
        (r'\b#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'issue #123 and issue#456',

			




	
	
	
		
 
            """issue #123 and """

			




	
	
	
		
 
            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

			




	
	
	
		
 
        (r'[ \t]#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'issue #123 and issue#456',

			




	
	
	
		
 
        # ... so maybe try to be explicit? Unfortunately the whitespace before the issue

			




	
	
	
		
 
        # reference is not retained, again, because it is part of the pattern.

			




	
	
	
		
 
        (r'(?:^|\s)#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            '#15 and issue #123 and issue#456',

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/15">#15</a> and """

			




	
	
	
		
 
            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issue#456"""),

			




	
	
	
		
 
        # ... instead, use lookbehind assertions.

			




	
	
	
		
 
        (r'(?:^|(?<=\s))#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            '#15 and issue #123 and issue#456',

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/15">#15</a> and """

			




	
	
	
		
 
            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

			




	
	
	
		
 
            """issue#456"""),

			




	
	
	
		
 
        (r'(?:pullrequest|pull request|PR|pr) ?#?(\d+)', 'http://foo/{repo}/issue/{id}', 'PR#',

			




	
	
	
		
 
            'fixed with pullrequest #1, pull request#2, PR 3, pr4',

			




	
	
	
		
 
            """fixed with <a class="issue-tracker-link" href="http://foo/repo_name/issue/1">PR#1</a>, """

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/2">PR#2</a>, """

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/3">PR#3</a>, """

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/4">PR#4</a>"""),

			




	
	
	
		
 
        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', 'PR',

			




	
	
	
		
 
            'interesting issue #123',

			




	
	
	
		
 
            """interesting issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">PR123</a>"""),

			




	
	
	
		
 
        (r'BUG\d{5}', 'https://bar/{repo}/{id}', 'BUG',

			




	
	
	
		
 
            'silly me, I did not parenthesize the {id}, BUG12345.',

			




	
	
	
		
 
            """silly me, I did not parenthesize the {id}, <a class="issue-tracker-link" href="https://bar/repo_name/">BUG</a>."""),

			




	
	
	
		
 
        (r'BUG(\d{5})', 'https://bar/{repo}/', 'BUG',

			




	
	
	
		
 
            'silly me, the URL does not contain {id}, BUG12345.',

			




	
	
	
		
 
            """silly me, the URL does not contain {id}, <a class="issue-tracker-link" href="https://bar/repo_name/">BUG12345</a>."""),

			




	
	
	
		
 
        (r'(PR-\d+)', 'http://foo/{repo}/issue/{id}', '',

			




	
	
	
		
 
            'interesting issue #123, err PR-56',

			




	
	
	
		
 
            """interesting issue #123, err <a class="issue-tracker-link" href="http://foo/repo_name/issue/PR-56">PR-56</a>"""),

			




	
	
	
		
 
        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            "some 'standard' text with apostrophes",

			




	
	
	
		
 
            """some &#39;standard&#39; text with apostrophes"""),

			




	
	
	
		
 
        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            "some 'standard' issue #123",

			




	
	
	
		
 
            """some &#39;standard&#39; issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>"""),

			




	
	
	
		
 
        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'an issue   #123       with extra whitespace',

			




	
	
	
		
 
            """an issue   <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

			




	
	
	
		
 
        # Note: whitespace is squashed

			




	
	
	
		
 
        (r'(?:\s*#)(\d+)', 'http://foo/{repo}/issue/{id}', '#',

			




	
	
	
		
 
            'an issue   #123       with extra whitespace',

			




	
	
	
		
 
            """an issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

			




	
	
	
		
 
        # invalid issue pattern

			




	
	
	
		
 
        (r'(PR\d+', 'http://foo/{repo}/issue/{id}', '',

			




	
	
	
		
 
            'PR135',

			




	
	
	
		
 
            """PR135"""),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_issues(self, issue_pat, issue_server, issue_prefix, sample, expected):

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        config_stub = {

			




	
	
	
		
 
            'sqlalchemy.url': 'foo',

			




	
	
	
		
 
            'issue_pat': issue_pat,

			




	
	
	
		
 
            'issue_server_link': issue_server,

			




	
	
	
		
 
            'issue_prefix': issue_prefix,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        # force recreation of lazy function

			




	
	
	
		
 
        with mock.patch('kallithea.lib.helpers._urlify_issues_f', None):

			




	
	
	
		
 
            with mock.patch('kallithea.CONFIG', config_stub):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('sample,expected', [

			




	
	
	
		
 
        ('abc X5', 'abc <a class="issue-tracker-link" href="http://main/repo_name/main/5/">#5</a>'),

			




	
	
	
		
 
        ('abc pullrequest #6 xyz', 'abc <a class="issue-tracker-link" href="http://pr/repo_name/pr/6">PR#6</a> xyz'),

			




	
	
	
		
 
        ('pull request7 #', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/7">PR#7</a> #'),

			




	
	
	
		
 
        ('look PR9 and pr #11', 'look <a class="issue-tracker-link" href="http://pr/repo_name/pr/9">PR#9</a> and <a class="issue-tracker-link" href="http://pr/repo_name/pr/11">PR#11</a>'),

			




	
	
	
		
 
        ('pullrequest#10 solves issue 9', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/10">PR#10</a> solves <a class="issue-tracker-link" href="http://bug/repo_name/bug/9">bug#9</a>'),

			




	
	
	
		
 
        ('issue FAIL67', 'issue <a class="issue-tracker-link" href="http://fail/repo_name/67">67</a>'),

			




	
	
	
		
 
        ('issue FAILMORE89', 'issue FAILMORE89'), # no match because absent prefix

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_issues_multiple_issue_patterns(self, sample, expected):

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        config_stub = {

			




	
	
	
		
 
            'sqlalchemy.url': 'foo',

			




	
	
	
		
 
            'issue_pat': 'X(\d+)',

			




	
	
	
		
 
            'issue_server_link': 'http://main/{repo}/main/{id}/',

			




	
	
	
		
 
            'issue_prefix': '#',

			




	
	
	
		
 
            'issue_pat_pr': '(?:pullrequest|pull request|PR|pr) ?#?(\d+)',

			




	
	
	
		
 
            'issue_server_link_pr': 'http://pr/{repo}/pr/{id}',

			




	
	
	
		
 
            'issue_prefix_pr': 'PR#',

			




	
	
	
		
 
            'issue_pat_bug': '(?:BUG|bug|issue) ?#?(\d+)',

			




	
	
	
		
 
            'issue_server_link_bug': 'http://bug/{repo}/bug/{id}',

			




	
	
	
		
 
            'issue_prefix_bug': 'bug#',

			




	
	
	
		
 
            'issue_pat_empty_prefix': 'FAIL(\d+)',

			




	
	
	
		
 
            'issue_server_link_empty_prefix': 'http://fail/{repo}/{id}',

			




	
	
	
		
 
            'issue_prefix_empty_prefix': '',

			




	
	
	
		
 
            'issue_pat_absent_prefix': 'FAILMORE(\d+)',

			




	
	
	
		
 
            'issue_server_link_absent_prefix': 'http://failmore/{repo}/{id}',

			




	
	
	
		
 
        }

			




	
	
	
		
 
        # force recreation of lazy function

			




	
	
	
		
 
        with mock.patch('kallithea.lib.helpers._urlify_issues_f', None):

			




	
	
	
		
 
            with mock.patch('kallithea.CONFIG', config_stub):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('test,expected', [

			




	
	
	
		
 
      ("", None),

			




	
	
	
		
 
      ("/_2", '2'),

			




	
	
	
		
 
      ("_2", '2'),

			




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

			




	
	
	
		
 
      ("_2/", '2'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_21", '21'),

			




	
	
	
		
 
      ("_21", '21'),

			




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

			




	
	
	
		
 
      ("_21/", '21'),

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: clio-20238
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.
            – Support