Changeset - d24051ce961c
Parent rev.
Child rev.
[Not reviewed]
default
0 5 0
Thomas De Schampheleire - 8 years ago 2018-03-10 22:01:59
thomas.de_schampheleire@nokia.com
issues: support generic regex replacements in issue_url and issue_prefix

Issue reference linking is pretty limited:
- the issue_url is a literal with only three special tokens {id},
{repo} and {repo_name}. There is no way to let the URL be dependent on
other elements of the input issue reference.
- The value for {id} is somewhat oddly determined by the concatenation of
all parenthesized groups in the issue_pat regular expression
- the link text of the resulting link is limited to the contents of the
literal issue_prefix with the determined {id}. It is not possible to
retain the input issue reference verbatim, nor to let the link text be
dependent on other elements of the input issue reference.

This commit makes the issue reference linking more flexible:

- issue_prefix is replaced by the more generic issue_sub(stitution), which
is a string that may contain backreferences to regex groups specified in
issue_pat. This string, with backreferences resolved, is used as the
link text of urlified issue references.
- if issue_sub is empty, the entire text matched by issue_pat is used as
the link text.
- like issue_sub, also issue_url can contain backreferences to regex groups.
- {id} is no longer treated as a special token, as it can be solved by
generic backreferences ('\g<id>' assuming issue pattern contains something
like '(P<id>\d+)'. {repo} and {repo_name} are still supported, because
their value is provided externally and not normally part of the
issue pattern.

Documentation and ini file template is updated as well.
5 files changed with 173 insertions and 101 deletions:
development.ini
27
17
docs/setup.rst
55
18
kallithea/lib/helpers.py
23
12
kallithea/lib/paster_commands/template.ini.mako
25
18
kallithea/tests/other/test_libs.py
43
36
0 comments (0 inline, 0 general)
development.ini
➞
Show inline comments
 
@@ -123,124 +123,134 @@ use_htsts = false
 
commit_parse_limit = 25
 

			




	
	
	
		
 
## path to git executable

			




	
	
	
		
 
git_path = git

			




	
	
	
		
 

			




	
	
	
		
 
## git rev filter option, --all is the default filter, if you need to

			




	
	
	
		
 
## hide all refs in changelog switch this to --branches --tags

			




	
	
	
		
 
#git_rev_filter = --branches --tags

			




	
	
	
		
 

			




	
	
	
		
 
## RSS feed options

			




	
	
	
		
 
rss_cut_off_limit = 256000

			




	
	
	
		
 
rss_items_per_page = 10

			




	
	
	
		
 
rss_include_diff = false

			




	
	
	
		
 

			




	
	
	
		
 
## options for showing and identifying changesets

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = false

			




	
	
	
		
 

			




	
	
	
		
 
## Canonical URL to use when creating full URLs in UI and texts.

			




	
	
	
		
 
## Useful when the site is available under different names or protocols.

			




	
	
	
		
 
## Defaults to what is provided in the WSGI environment.

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## gist URL alias, used to create nicer urls for gist. This should be an

			




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

			




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

			




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

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
## white list of API enabled controllers. This allows to add list of

			




	
	
	
		
 
## controllers to which access will be enabled by api_key. eg: to enable

			




	
	
	
		
 
## api access to raw_files put `FilesController:raw`, to enable access to patches

			




	
	
	
		
 
## add `ChangesetController:changeset_patch`. This list should be "," separated

			




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

			




	
	
	
		
 
## Recommended settings below are commented out:

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
## default encoding used to convert from and to unicode

			




	
	
	
		
 
## can be also a comma separated list of encoding in case of mixed encodings

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracker for Kallithea (leave blank to disable, absent for default)

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracking mapping for commits messages

			




	
	
	
		
 
## comment out issue_pat, issue_server, issue_prefix to enable

			




	
	
	
		
 
## issue tracking mapping for commit messages, comments, PR descriptions, ...

			




	
	
	
		
 
## Refer to the documentation ("Integration with issue trackers") for more details.

			




	
	
	
		
 

			




	
	
	
		
 
## pattern to get the issues from commit messages

			




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

			




	
	
	
		
 
## {id} will be all groups matched from this pattern

			




	
	
	
		
 
## regular expression to match issue references

			




	
	
	
		
 
## This pattern may/should contain parenthesized groups, that can

			




	
	
	
		
 
## be referred to in issue_server_link or issue_sub using Python backreferences

			




	
	
	
		
 
## (e.g. \1, \2, ...). You can also create named groups with '(?P<groupname>)'.

			




	
	
	
		
 
## To require mandatory whitespace before the issue pattern, use:

			




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

			




	
	
	
		
 
## behind the issue pattern, use (?:$|(?=\s)) after the actual pattern.

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = #(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
## server url to the issue, each {id} will be replaced with match

			




	
	
	
		
 
## fetched from the regex and {repo} is replaced with full repository name

			




	
	
	
		
 
## including groups {repo_name} is replaced with just name of repo

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## server url to the issue

			




	
	
	
		
 
## This pattern may/should contain backreferences to parenthesized groups in issue_pat.

			




	
	
	
		
 
## A backreference can be \1, \2, ... or \g<groupname> if you specified a named group

			




	
	
	
		
 
## called 'groupname' in issue_pat.

			




	
	
	
		
 
## The special token {repo} is replaced with the full repository name

			




	
	
	
		
 
## including repository groups, while {repo_name} is replaced with just

			




	
	
	
		
 
## the name of the repository.

			




	
	
	
		
 

			




	
	
	
		
 
## prefix to add to link to indicate it's an url

			




	
	
	
		
 
## #314 will be replaced by <issue_prefix><id>

			




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

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 
## substitution pattern to use as the link text

			




	
	
	
		
 
## If issue_sub is empty, the text matched by issue_pat is retained verbatim

			




	
	
	
		
 
## for the link text. Otherwise, the link text is that of issue_sub, with any

			




	
	
	
		
 
## backreferences to groups in issue_pat replaced.

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

			




	
	
	
		
 
issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link and issue_sub can have suffixes to specify

			




	
	
	
		
 
## multiple patterns, to other issues server, wiki or others

			




	
	
	
		
 
## below an example how to create a wiki pattern

			




	
	
	
		
 
# 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-

			




	
	
	
		
 
#issue_pat_wiki = wiki-(\S+)

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/\1

			




	
	
	
		
 
#issue_sub_wiki = WIKI-\1

			




	
	
	
		
 

			




	
	
	
		
 
## alternative return HTTP header for failed authentication. Default HTTP

			




	
	
	
		
 
## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

			




	
	
	
		
 
## handling that. Set this variable to 403 to return HTTPForbidden

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
## locking return code. When repository is locked return this HTTP code. 2XX

			




	
	
	
		
 
## codes don't break the transactions while 4XX codes do

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




	
	
	
		
 
## allows to change the repository location in settings page

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




	
	
	
		
 
## allows to setup custom hooks in settings page

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




	
	
	
		
 
## extra extensions for indexing, space separated and without the leading '.'.

			




	
	
	
		
 
# index.extensions =

			




	
	
	
		
 
#    gemfile

			




	
	
	
		
 
#    lock

			




	
	
	
		
 

			




	
	
	
		
 
## extra filenames for indexing, space separated

			




	
	
	
		
 
# index.filenames =

			




	
	
	
		
 
#    .dockerignore

			




	
	
	
		
 
#    .editorconfig

			




	
	
	
		
 
#    INSTALL

			




	
	
	
		
 
#    CHANGELOG

			




	
	
	
		
 

			




	
	
	
		
 
####################################

			




	
	
	
		
 
###        CELERY CONFIG        ####

			




	
	
	
		
 
####################################

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 

			




	
	
	
		
 
## Example: connect to the virtual host 'rabbitmqhost' on localhost as rabbitmq:

			




	
	
	
		
 
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

			




        

    


    
    

    

        

                

                    docs/setup.rst
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -490,134 +490,170 @@ could set the request headers however yo

			




	
	
	
		
 

			




	
	
	
		
 
    from mod_python import apache

			




	
	
	
		
 
    import ldap

			




	
	
	
		
 

			




	
	
	
		
 
    LDAP_SERVER = "ldaps://server.mydomain.com:636"

			




	
	
	
		
 
    LDAP_USER = ""

			




	
	
	
		
 
    LDAP_PASS = ""

			




	
	
	
		
 
    LDAP_ROOT = "dc=mydomain,dc=com"

			




	
	
	
		
 
    LDAP_FILTER = "sAMAccountName=%s"

			




	
	
	
		
 
    LDAP_ATTR_LIST = ['sAMAccountName','givenname','sn','mail']

			




	
	
	
		
 

			




	
	
	
		
 
    def fixuphandler(req):

			




	
	
	
		
 
        if req.user is None:

			




	
	
	
		
 
            # no user to search for

			




	
	
	
		
 
            return apache.OK

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                if('\\' in req.user):

			




	
	
	
		
 
                    username = req.user.split('\\')[1]

			




	
	
	
		
 
                elif('@' in req.user):

			




	
	
	
		
 
                    username = req.user.split('@')[0]

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    username = req.user

			




	
	
	
		
 
                l = ldap.initialize(LDAP_SERVER)

			




	
	
	
		
 
                l.simple_bind_s(LDAP_USER, LDAP_PASS)

			




	
	
	
		
 
                r = l.search_s(LDAP_ROOT, ldap.SCOPE_SUBTREE, LDAP_FILTER % username, attrlist=LDAP_ATTR_LIST)

			




	
	
	
		
 

			




	
	
	
		
 
                req.subprocess_env['X_REMOTE_USER'] = username

			




	
	
	
		
 
                req.subprocess_env['X_REMOTE_EMAIL'] = r[0][1]['mail'][0].lower()

			




	
	
	
		
 
                req.subprocess_env['X_REMOTE_FIRSTNAME'] = "%s" % r[0][1]['givenname'][0]

			




	
	
	
		
 
                req.subprocess_env['X_REMOTE_LASTNAME'] = "%s" % r[0][1]['sn'][0]

			




	
	
	
		
 
            except Exception, e:

			




	
	
	
		
 
                apache.log_error("error getting data from ldap %s" % str(e), apache.APLOG_ERR)

			




	
	
	
		
 

			




	
	
	
		
 
            return apache.OK

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 
   If you enable proxy pass-through authentication, make sure your server is

			




	
	
	
		
 
   only accessible through the proxy. Otherwise, any client would be able to

			




	
	
	
		
 
   forge the authentication header and could effectively become authenticated

			




	
	
	
		
 
   using any account of their liking.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Integration with issue trackers

			




	
	
	
		
 
-------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea provides a simple integration with issue trackers. It's possible

			




	
	
	
		
 
to define a regular expression that will match an issue ID in commit messages,

			




	
	
	
		
 
and have that replaced with a URL to the issue. To enable this simply

			




	
	
	
		
 
uncomment the following variables in the ini file::

			




	
	
	
		
 
and have that replaced with a URL to the issue.

			




	
	
	
		
 

			




	
	
	
		
 
This is achieved with following three variables in the ini file::

			




	
	
	
		
 

			




	
	
	
		
 
    issue_pat = (?:^#|\s#)(\w+)

			




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

			




	
	
	
		
 
    issue_prefix = #

			




	
	
	
		
 
    issue_pat = #(\d+)

			




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

			




	
	
	
		
 
    issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
``issue_pat`` is the regular expression describing which strings in

			




	
	
	
		
 
commit messages will be treated as issue references. A match group in

			




	
	
	
		
 
parentheses should be used to specify the actual issue id.

			




	
	
	
		
 
commit messages will be treated as issue references. The expression can/should

			




	
	
	
		
 
have one or more parenthesized groups that can later be referred to in

			




	
	
	
		
 
``issue_server_link`` and ``issue_sub`` (see below). If you prefer, named groups

			




	
	
	
		
 
can be used instead of simple parenthesized groups.

			




	
	
	
		
 

			




	
	
	
		
 
The default expression matches issues in the format ``#<number>``, e.g., ``#300``.

			




	
	
	
		
 
If the pattern should only match if it is preceded by whitespace, add the

			




	
	
	
		
 
following string before the actual pattern: ``(?:^|(?<=\s))``.

			




	
	
	
		
 
If the pattern should only match if it is followed by whitespace, add the

			




	
	
	
		
 
following string after the actual pattern: ``(?:$|(?=\s))``.

			




	
	
	
		
 
These expressions use lookbehind and lookahead assertions of the Python regular

			




	
	
	
		
 
expression module to avoid the whitespace to be part of the actual pattern,

			




	
	
	
		
 
otherwise the link text will also contain that whitespace.

			




	
	
	
		
 

			




	
	
	
		
 
Matched issue references are replaced with the link specified in

			




	
	
	
		
 
``issue_server_link``. ``{id}`` is replaced with the issue ID, and

			




	
	
	
		
 
``{repo}`` with the repository name.  Since the # is stripped away,

			




	
	
	
		
 
``issue_prefix`` is prepended to the link text.  ``issue_prefix`` doesn't

			




	
	
	
		
 
necessarily need to be ``#``: if you set issue prefix to ``ISSUE-`` this will

			




	
	
	
		
 
generate a URL in the format:

			




	
	
	
		
 
``issue_server_link``, in which any backreferences are resolved. Backreferences

			




	
	
	
		
 
can be ``\1``, ``\2``, ... or for named groups ``\g<groupname>``.

			




	
	
	
		
 
The special token ``{repo}`` is replaced with the full repository path

			




	
	
	
		
 
(including repository groups), while token ``{repo_name}`` is replaced with the

			




	
	
	
		
 
repository name (without repository groups).

			




	
	
	
		
 

			




	
	
	
		
 
The link text is determined by ``issue_sub``, which can be a string containing

			




	
	
	
		
 
backreferences to the groups specified in ``issue_pat``. If ``issue_sub`` is

			




	
	
	
		
 
empty, then the text matched by ``issue_pat`` is used verbatim.

			




	
	
	
		
 

			




	
	
	
		
 
The example settings shown above match issues in the format ``#<number>``.

			




	
	
	
		
 
This will cause the text ``#300`` to be transformed into a link:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: html

			




	
	
	
		
 

			




	
	
	
		
 
  <a href="https://issues.example.com/example_repo/issue/300">ISSUE-300</a>

			




	
	
	
		
 
  <a href="https://issues.example.com/example_repo/issue/300">#300</a>

			




	
	
	
		
 

			




	
	
	
		
 
The following example transforms a text starting with either of 'pullrequest',

			




	
	
	
		
 
'pull request' or 'PR', followed by an optional space, then a pound character

			




	
	
	
		
 
(#) and one or more digits, into a link with the text 'PR #' followed by the

			




	
	
	
		
 
digits::

			




	
	
	
		
 

			




	
	
	
		
 
    issue_pat = (pullrequest|pull request|PR) ?#(\d+)

			




	
	
	
		
 
    issue_server_link = https://issues.example.com/\2

			




	
	
	
		
 
    issue_sub = PR #\2

			




	
	
	
		
 

			




	
	
	
		
 
The following example demonstrates how to require whitespace before the issue

			




	
	
	
		
 
reference in order for it to be recognized, such that the text ``issue#123`` will

			




	
	
	
		
 
not cause a match, but ``issue #123`` will::

			




	
	
	
		
 

			




	
	
	
		
 
    issue_pat = (?:^|(?<=\s))#(\d+)

			




	
	
	
		
 
    issue_server_link = https://issues.example.com/\1

			




	
	
	
		
 
    issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
If needed, more than one pattern can be specified by appending a unique suffix to

			




	
	
	
		
 
the variables. For example::

			




	
	
	
		
 
the variables. For example, also demonstrating the use of named groups::

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
    issue_prefix_wiki = WIKI-

			




	
	
	
		
 
    issue_pat_wiki = wiki-(?P<pagename>\S+)

			




	
	
	
		
 
    issue_server_link_wiki = https://wiki.example.com/\g<pagename>

			




	
	
	
		
 
    issue_sub_wiki = WIKI-\g<pagename>

			




	
	
	
		
 

			




	
	
	
		
 
With these settings, wiki pages can be referenced as wiki-some-id, and every

			




	
	
	
		
 
such reference will be transformed into:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: html

			




	
	
	
		
 

			




	
	
	
		
 
  <a href="https://wiki.example.com/some-id">WIKI-some-id</a>

			




	
	
	
		
 

			




	
	
	
		
 
Refer to the `Python regular expression documentation`_ for more details about

			




	
	
	
		
 
the supported syntax in ``issue_pat``, ``issue_server_link`` and ``issue_sub``.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Hook management

			




	
	
	
		
 
---------------

			




	
	
	
		
 

			




	
	
	
		
 
Hooks can be managed in similar way to that used in ``.hgrc`` files.

			




	
	
	
		
 
To manage hooks, choose *Admin > Settings > Hooks*.

			




	
	
	
		
 

			




	
	
	
		
 
The built-in hooks cannot be modified, though they can be enabled or disabled in the *VCS* section.

			




	
	
	
		
 

			




	
	
	
		
 
To add another custom hook simply fill in the first textbox with

			




	
	
	
		
 
``<name>.<hook_type>`` and the second with the hook path. Example hooks

			




	
	
	
		
 
can be found in ``kallithea.lib.hooks``.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Changing default encoding

			




	
	
	
		
 
-------------------------

			




	
	
	
		
 

			




	
	
	
		
 
By default, Kallithea uses UTF-8 encoding.

			




	
	
	
		
 
This is configurable as ``default_encoding`` in the .ini file.

			




	
	
	
		
 
This affects many parts in Kallithea including user names, filenames, and

			




	
	
	
		
 
encoding of commit messages. In addition Kallithea can detect if the ``chardet``

			




	
	
	
		
 
library is installed. If ``chardet`` is detected Kallithea will fallback to it

			




	
	
	
		
 
when there are encode/decode errors.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Celery configuration

			




	
	
	
		
 
--------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea can use the distributed task queue system Celery_ to run tasks like

			




	
	
	
		
 
cloning repositories or sending emails.

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea will in most setups work perfectly fine out of the box (without

			




	
	
	
		
 
Celery), executing all tasks in the web server process. Some tasks can however

			




	
	
	
		
 
take some time to run and it can be better to run such tasks asynchronously in

			




	
	
	
		
 
a separate process so the web server can focus on serving web requests.

			




	
	
	
		
 

			




	
	
	
		
 
For installation and configuration of Celery, see the `Celery documentation`_.

			




	
	
	
		
 
Note that Celery requires a message broker service like RabbitMQ_ (recommended)

			




	
	
	
		
 
or Redis_.

			




	
	
	
		
 

			




	
	
	
		
 
The use of Celery is configured in the Kallithea ini configuration file.

			




	
	
	
		
 
To enable it, simply set::

			




	
	
	
		
 

			




	
	
	
		
 
  use_celery = true

			




	
	
	
		
 

			




	
	
	
		
 
and add or change the ``celery.*`` and ``broker.*`` configuration variables.

			




	
	
	
		
 

			




	
	
	
		
 
Remember that the ini files use the format with '.' and not with '_' like

			




	
	
		
 
@@ -856,56 +892,57 @@ WSGIDaemonProcess to set the name of the

			




	
	
	
		
 
Example WSGI dispatch script:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: python

			




	
	
	
		
 

			




	
	
	
		
 
    import os

			




	
	
	
		
 
    os.environ["HGENCODING"] = "UTF-8"

			




	
	
	
		
 
    os.environ['PYTHON_EGG_CACHE'] = '/srv/kallithea/.egg-cache'

			




	
	
	
		
 

			




	
	
	
		
 
    # sometimes it's needed to set the current dir

			




	
	
	
		
 
    os.chdir('/srv/kallithea/')

			




	
	
	
		
 

			




	
	
	
		
 
    import site

			




	
	
	
		
 
    site.addsitedir("/srv/kallithea/venv/lib/python2.7/site-packages")

			




	
	
	
		
 

			




	
	
	
		
 
    ini = '/srv/kallithea/my.ini'

			




	
	
	
		
 
    from paste.script.util.logging_config import fileConfig

			




	
	
	
		
 
    fileConfig(ini)

			




	
	
	
		
 
    from paste.deploy import loadapp

			




	
	
	
		
 
    application = loadapp('config:' + ini)

			




	
	
	
		
 

			




	
	
	
		
 
Or using proper virtualenv activation:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: python

			




	
	
	
		
 

			




	
	
	
		
 
    activate_this = '/srv/kallithea/venv/bin/activate_this.py'

			




	
	
	
		
 
    execfile(activate_this, dict(__file__=activate_this))

			




	
	
	
		
 

			




	
	
	
		
 
    import os

			




	
	
	
		
 
    os.environ['HOME'] = '/srv/kallithea'

			




	
	
	
		
 

			




	
	
	
		
 
    ini = '/srv/kallithea/kallithea.ini'

			




	
	
	
		
 
    from paste.script.util.logging_config import fileConfig

			




	
	
	
		
 
    fileConfig(ini)

			




	
	
	
		
 
    from paste.deploy import loadapp

			




	
	
	
		
 
    application = loadapp('config:' + ini)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Other configuration files

			




	
	
	
		
 
-------------------------

			




	
	
	
		
 

			




	
	
	
		
 
A number of `example init.d scripts`__ can be found in

			




	
	
	
		
 
the ``init.d`` directory of the Kallithea source.

			




	
	
	
		
 

			




	
	
	
		
 
.. __: https://kallithea-scm.org/repos/kallithea/files/tip/init.d/ .

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
.. _virtualenv: http://pypi.python.org/pypi/virtualenv

			




	
	
	
		
 
.. _python: http://www.python.org/

			




	
	
	
		
 
.. _Python regular expression documentation: https://docs.python.org/2/library/re.html

			




	
	
	
		
 
.. _Mercurial: https://www.mercurial-scm.org/

			




	
	
	
		
 
.. _Celery: http://celeryproject.org/

			




	
	
	
		
 
.. _Celery documentation: http://docs.celeryproject.org/en/latest/getting-started/index.html

			




	
	
	
		
 
.. _RabbitMQ: http://www.rabbitmq.com/

			




	
	
	
		
 
.. _Redis: http://redis.io/

			




	
	
	
		
 
.. _python-ldap: http://www.python-ldap.org/

			




	
	
	
		
 
.. _mercurial-server: http://www.lshift.net/mercurial-server.html

			




	
	
	
		
 
.. _PublishingRepositories: https://www.mercurial-scm.org/wiki/PublishingRepositories

			




        

    


    
    

    

        

                

                    kallithea/lib/helpers.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -1095,125 +1095,136 @@ def urlify_text(s, repo_name=None, link_

			




	
	
	
		
 
    # 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)

			




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

			




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

			




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

			




	
	
	
		
 
                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))

			




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

			




	
	
	
		
 
                continue

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
            def issues_replace(match_obj,

			




	
	
	
		
 
                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

			




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

			




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

			




	
	
	
		
 
                               issue_server_link=issue_server_link, issue_sub=issue_sub):

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    issue_url = match_obj.expand(issue_server_link)

			




	
	
	
		
 
                except (IndexError, re.error) as e:

			




	
	
	
		
 
                    log.error('invalid issue_url setting %r -> %r %r. Error: %s', issue_pat, issue_server_link, issue_sub, str(e))

			




	
	
	
		
 
                    issue_url = issue_server_link

			




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

			




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

			




	
	
	
		
 
                # if issue_sub is empty use the matched issue reference verbatim

			




	
	
	
		
 
                if not issue_sub:

			




	
	
	
		
 
                    issue_text = match_obj.group()

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    try:

			




	
	
	
		
 
                        issue_text = match_obj.expand(issue_sub)

			




	
	
	
		
 
                    except (IndexError, re.error) as e:

			




	
	
	
		
 
                        log.error('invalid issue_sub setting %r -> %r %r. Error: %s', issue_pat, issue_server_link, issue_sub, str(e))

			




	
	
	
		
 
                        issue_text = match_obj.group()

			




	
	
	
		
 

			




	
	
	
		
 
                return (

			




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

			




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

			




	
	
	
		
 
                    '%(text)s'

			




	
	
	
		
 
                    '</a>'

			




	
	
	
		
 
                    ) % {

			




	
	
	
		
 
                     'url': issue_url,

			




	
	
	
		
 
                     'id-repr': issue_id,

			




	
	
	
		
 
                     'issue-prefix': issue_prefix,

			




	
	
	
		
 
                     'serv': issue_server_link,

			




	
	
	
		
 
                     'text': issue_text,

			




	
	
	
		
 
                    }

			




	
	
	
		
 
            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)

			




        

    


    
    

    

        

                

                    kallithea/lib/paster_commands/template.ini.mako
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -216,127 +216,134 @@ use_htsts = false

			




	
	
	
		
 
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>## issue tracking mapping for commit messages, comments, PR descriptions, ...</%text>

			




	
	
	
		
 
<%text>## Refer to the documentation ("Integration with issue trackers") for more details.</%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>## regular expression to match issue references</%text>

			




	
	
	
		
 
<%text>## This pattern may/should contain parenthesized groups, that can</%text>

			




	
	
	
		
 
<%text>## be referred to in issue_server_link or issue_sub using Python backreferences</%text>

			




	
	
	
		
 
<%text>## (e.g. \1, \2, ...). You can also create named groups with '(?P<groupname>)'.</%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>

			




	
	
	
		
 
<%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>## server url to the issue</%text>

			




	
	
	
		
 
<%text>## This pattern may/should contain backreferences to parenthesized groups in issue_pat.</%text>

			




	
	
	
		
 
<%text>## A backreference can be \1, \2, ... or \g<groupname> if you specified a named group</%text>

			




	
	
	
		
 
<%text>## called 'groupname' in issue_pat.</%text>

			




	
	
	
		
 
<%text>## The special token {repo} is replaced with the full repository name</%text>

			




	
	
	
		
 
<%text>## including repository groups, while {repo_name} is replaced with just</%text>

			




	
	
	
		
 
<%text>## the name of the repository.</%text>

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 
<%text>## substitution pattern to use as the link text</%text>

			




	
	
	
		
 
<%text>## If issue_sub is empty, the text matched by issue_pat is retained verbatim</%text>

			




	
	
	
		
 
<%text>## for the link text. Otherwise, the link text is that of issue_sub, with any</%text>

			




	
	
	
		
 
<%text>## backreferences to groups in issue_pat replaced.</%text>

			




	
	
	
		
 

			




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

			




	
	
	
		
 
issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue_pat, issue_server_link and issue_sub 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-

			




	
	
	
		
 
#issue_pat_wiki = wiki-(\S+)

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/\1

			




	
	
	
		
 
#issue_sub_wiki = WIKI-\1

			




	
	
	
		
 

			




	
	
	
		
 
<%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

			




        

    


    
    

    

        

                

                    kallithea/tests/other/test_libs.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -361,186 +361,193 @@ class TestLibs(TestController):

			




	
	
	
		
 
       """       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}', '#',

			




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

			




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

			




	
	
	
		
 
            '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}', '#',

			




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

			




	
	
	
		
 
            '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>"""),

			




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

			




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

			




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

			




	
	
	
		
 
            'issue PR123 and issuePR456',

			




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

			




	
	
	
		
 
            """issuePR456"""),

			




	
	
	
		
 
        # ... 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}', '#',

			




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

			




	
	
	
		
 
            'issue #123 and issue#456',

			




	
	
	
		
 
            """issue #123 and """

			




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

			




	
	
	
		
 
        # ... 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}', '#',

			




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

			




	
	
	
		
 
            '#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}', '#',

			




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

			




	
	
	
		
 
            '#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#',

			




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

			




	
	
	
		
 
            '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',

			




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

			




	
	
	
		
 
            '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}', '',

			




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

			




	
	
	
		
 
            '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/\\1">BUG12345</a>."""),

			




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

			




	
	
	
		
 
            '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/\\1', '',

			




	
	
	
		
 
            '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}', '#',

			




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

			




	
	
	
		
 
            "some 'standard' text with apostrophes",

			




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

			




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

			




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

			




	
	
	
		
 
            "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}', '#',

			




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

			




	
	
	
		
 
            '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}', '#',

			




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

			




	
	
	
		
 
            '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"""),

			




	
	
	
		
 
            """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"""),

			




	
	
	
		
 
        # other character than #

			




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

			




	
	
	
		
 
            'empty issue_sub $123 and issue$456',

			




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

			




	
	
	
		
 
            """issue$456"""),

			




	
	
	
		
 
        # named groups

			




	
	
	
		
 
        (r'(PR|pullrequest|pull request) ?(?P<sitecode>BRU|CPH|BER)-(?P<id>\d+)', 'http://foo/\g<sitecode>/pullrequest/\g<id>/', 'PR-\g<sitecode>-\g<id>',

			




	
	
	
		
 
            'pullrequest CPH-789 is similar to PRBRU-747',

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/CPH/pullrequest/789/">PR-CPH-789</a> is similar to """

			




	
	
	
		
 
            """<a class="issue-tracker-link" href="http://foo/BRU/pullrequest/747/">PR-BRU-747</a>"""),

			




	
	
	
		
 
    ])

			




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

			




	
	
	
		
 
    def test_urlify_issues(self, issue_pat, issue_server, issue_sub, 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,

			




	
	
	
		
 
            'issue_sub': issue_sub,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        # 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 FAIL67', 'issue <a class="issue-tracker-link" href="http://fail/repo_name/67">FAIL67</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_server_link': 'http://main/{repo}/main/\\1/',

			




	
	
	
		
 
            'issue_sub': '#\\1',

			




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

			




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

			




	
	
	
		
 
            'issue_prefix_pr': 'PR#',

			




	
	
	
		
 
            'issue_server_link_pr': 'http://pr/{repo}/pr/\\1',

			




	
	
	
		
 
            'issue_sub_pr': 'PR#\\1',

			




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

			




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

			




	
	
	
		
 
            'issue_prefix_bug': 'bug#',

			




	
	
	
		
 
            'issue_server_link_bug': 'http://bug/{repo}/bug/\\1',

			




	
	
	
		
 
            'issue_sub_bug': 'bug#\\1',

			




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

			




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

			




	
	
	
		
 
            'issue_prefix_empty_prefix': '',

			




	
	
	
		
 
            'issue_server_link_empty_prefix': 'http://fail/{repo}/\\1',

			




	
	
	
		
 
            'issue_sub_empty_prefix': '',

			




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

			




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

			




	
	
	
		
 
            'issue_server_link_absent_prefix': 'http://failmore/{repo}/\\1',

			




	
	
	
		
 
        }

			




	
	
	
		
 
        # 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'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_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.