release: Merge default into stable for release preparation

docs/admin/svn-http.rst

@@ -0,0 +1,137 b''
+.. _svn-http:
+
+|svn| With Write Over HTTP
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To use |svn| with read/write support over the |svn| HTTP protocol, you have to
+configure the HTTP |svn| backend.
+
+Prerequisites
+=============
+
+- Enable HTTP support inside the admin VCS settings on your |RCE| instance
+- You need to install the following tools on the machine that is running an
+  instance of |RCE|:
+  ``Apache HTTP Server`` and ``mod_dav_svn``.
+
+
+Using Ubuntu 14.04 Distribution as an example execute the following:
+
+.. code-block:: bash
+
+    $ sudo apt-get install apache2 libapache2-mod-svn
+
+Once installed you need to enable ``dav_svn``:
+
+.. code-block:: bash
+
+    $ sudo a2enmod dav_svn
+    $ sudo a2enmod headers
+
+
+Configuring Apache Setup
+========================
+
+.. tip::
+
+   It is recommended to run Apache on a port other than 80, due to possible
+   conflicts with other HTTP servers like nginx. To do this, set the
+   ``Listen`` parameter in the ``/etc/apache2/ports.conf`` file, for example
+   ``Listen 8090``.
+
+
+.. warning::
+
+   Make sure your Apache instance which runs the mod_dav_svn module is
+   only accessible by |RCE|. Otherwise everyone is able to browse
+   the repositories or run subversion operations (checkout/commit/etc.).
+
+It is also recommended to run apache as the same user as |RCE|, otherwise
+permission issues could occur. To do this edit the ``/etc/apache2/envvars``
+
+   .. code-block:: apache
+
+      export APACHE_RUN_USER=rhodecode
+      export APACHE_RUN_GROUP=rhodecode
+
+1. To configure Apache, create and edit a virtual hosts file, for example
+   :file:`/etc/apache2/sites-available/default.conf`. Below is an example
+   how to use one with auto-generated config ```mod_dav_svn.conf```
+   from configured |RCE| instance.
+
+.. code-block:: apache
+
+    <VirtualHost *:8090>
+        ServerAdmin rhodecode-admin@localhost
+        DocumentRoot /var/www/html
+        ErrorLog ${'${APACHE_LOG_DIR}'}/error.log
+        CustomLog ${'${APACHE_LOG_DIR}'}/access.log combined
+        Include /home/user/.rccontrol/enterprise-1/mod_dav_svn.conf
+    </VirtualHost>
+
+
+2. Go to the :menuselection:`Admin --> Settings --> VCS` page, and
+   enable :guilabel:`Proxy Subversion HTTP requests`, and specify the
+   :guilabel:`Subversion HTTP Server URL`.
+
+3. Open the |RCE| configuration file,
+   :file:`/home/{user}/.rccontrol/{instance-id}/rhodecode.ini`
+
+4. Add the following configuration option in the ``[app:main]``
+   section if you don't have it yet.
+
+   This enables mapping of the created |RCE| repo groups into special
+   |svn| paths. Each time a new repository group is created, the system will
+   update the template file and create new mapping. Apache web server needs to
+   be reloaded to pick up the changes on this file.
+   To do this, simply configure `svn.proxy.reload_cmd` inside the .ini file.
+   Example configuration:
+
+
+.. code-block:: ini
+
+    ############################################################
+    ### Subversion proxy support (mod_dav_svn)               ###
+    ### Maps RhodeCode repo groups into SVN paths for Apache ###
+    ############################################################
+    ## Enable or disable the config file generation.
+    svn.proxy.generate_config = true
+    ## Generate config file with `SVNListParentPath` set to `On`.
+    svn.proxy.list_parent_path = true
+    ## Set location and file name of generated config file.
+    svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
+    ## Used as a prefix to the <Location> block in the generated config file.
+    ## In most cases it should be set to `/`.
+    svn.proxy.location_root = /
+    ## Command to reload the mod dav svn configuration on change.
+    ## Example: `/etc/init.d/apache2 reload`
+    svn.proxy.reload_cmd = /etc/init.d/apache2 reload
+    ## If the timeout expires before the reload command finishes, the command will
+    ## be killed. Setting it to zero means no timeout. Defaults to 10 seconds.
+    #svn.proxy.reload_timeout = 10
+
+
+This would create a special template file called ```mod_dav_svn.conf```. We
+used that file path in the apache config above inside the Include statement.
+It's also possible to generate the config from the
+:menuselection:`Admin --> Settings --> VCS` page.
+
+
+Using |svn|
+===========
+
+Once |svn| has been enabled on your instance, you can use it with the
+following examples. For more |svn| information, see the `Subversion Red Book`_
+
+.. code-block:: bash
+
+    # To clone a repository
+    svn checkout http://my-svn-server.example.com/my-svn-repo
+
+    # svn commit
+    svn commit
+
+
+.. _Subversion Red Book: http://svnbook.red-bean.com/en/1.7/svn-book.html#svn.ref.svn
+
+.. _Ask Ubuntu: http://askubuntu.com/questions/162391/how-do-i-fix-my-locale-issue
  No newline at end of file

docs/contributing/checklist-pull-request.rst

@@ -0,0 +1,17 b''
+.. _checklist-pull-request:
+
+=======================
+Pull Request Checklists
+=======================
+
+
+
+Checklists for Pull Request
+===========================
+
+
+- Informative description
+- Linear commit history
+- Rebased on top of latest changes
+- Add ticket references. eg fixes #123, references #123 etc.
+

docs/release-notes/release-notes-4.5.0.rst

@@ -0,0 +1,159 b''
+|RCE| 4.5.0 |RNS|
+-----------------
+
+Release Date
+^^^^^^^^^^^^
+
+- 2016-12-02
+
+
+New Features
+^^^^^^^^^^^^
+
+- Diffs: re-implemented diff engine. Added: Syntax highlighting inside diffs,
+  new side-by-side view with commenting and live chat. Enabled soft-wrapping of
+  long lines and much improved rendering speed for large diffs.
+- File source view: new file display engine. File view now
+  soft wraps long lines. Double click inside file view show occurrences of
+  clicked item. Added pygments-markdown-lexer for highlighting markdown syntax.
+- Files annotation: Added new grouped annotations. Color all related commits
+  by double clicking singe commit in annotation view.
+- Pull request reviewers (EE only): added new default reviewers functionality.
+  Allows picking users or user groups defined as reviewers for new pull request.
+  Picking reviewers can be based on branch name, changed file name patterns or
+  original author of changed source code. eg *.css -> design team.
+  Master branch -> repo owner, fixes #1131.
+- Pull request reviewers: store and show reasons why given person is a reviewer.
+  Manually adding reviewers after creating a PR will now be also indicated
+  together with who added a given person to review.
+- Integrations: Webhooks integration now allows to use variables inside the
+  call URL. Currently supported variables are ${repo_name}, ${repo_type},
+  ${repo_id}, ${repo_url}, ${branch}, ${commit_id}, ${pull_request_id},
+  ${pull_request_url}. Commits are now grouped by branches as well.
+  Allows much easier integration with CI systems.
+- Integrations (EE only): allow wildcard * project key in Jira integration
+  settings to allow referencing multiple projects per commit, fixes #4267.
+- Live notifications: RhodeCode sends live notification to online
+  users on certain events and pages. Currently this works on: invite to chat,
+  update pull request, commit/inline comment. Part of live code review system.
+  Allows users to update the reviewed code while doing the review and never
+  miss any updates or comment replies as they happen. Requires channelstream
+  to be enabled.
+- Repository groups: added default personal repository groups. Personal groups
+  are isolated playground for users allowing them to create projects or forks.
+  Adds new setting to automatically create personal repo groups for newly
+  created users. New groups are created from specified pattern, for example
+  /u/{username}. Implements #4003.
+- Security: It's now possible to disable password reset functionality.
+  This is useful for cases when users only use LDAP or similar types of
+  authentication. Implements #3944
+- Pull requests: exposed shadow repositories to end users. Users are now given
+  access to the shadow repository which represents state after merge performed.
+  In this way users or especially CI servers can much easier perform code
+  analysis of the final merged code.
+- Pull requests: My account > pull request page now uses datagrid.
+  It's faster, filterable and sortable. Fixes #4297.
+- Pull requests: delete pull request action was moved from my account
+  into pull request view itself. This is where everyone was looking for it.
+- Pull requests: improve showing failed merges with proper status in pull
+  request page.
+- User groups: overhaul of edit user group page. Added new selector for
+  adding new user group members.
+- Licensing (EE only): exposed unlock link to deactivate users that are over
+  license limit, to unlock full functionality. This might happen when migrating
+  from CE into EE, and your license supports less active users then allowed.
+- Global settings: add a new header/footer template to allow flash filtering.
+  In case a license warning appears and admin wants to hide it for some time.
+  The new template can be used to do this.
+- System info: added create snapshot button to easily generate system state
+  report. Comes in handy for support and reporting. System state holds
+  information such as free disk/memory, CPU load and some of RhodeCode settings.
+- System info: fetch and show vcs settings from vcsserver. Fixes #4276.
+- System info: use real memory usage based on new psutil api available.
+- System info: added info about temporary storage.
+- System info: expose inode limits and usage. Fixes #4282.
+- Ui: added new icon for merge commit.
+
+
+
+General
+^^^^^^^
+
+- Notifications: move all notifications into polymer for consistency.
+  Fixes #4201.
+- Live chat (EE): Improved UI for live-chat. Use Codemirror editor as
+  input for text box.
+- Api: WARNING DEPRECATION, refactor repository group schemas. Fixes #4133.
+  When using create_repo, create_repo_group, update_repo, update_repo_group
+  the *_name parameter now takes full path including sub repository groups.
+  This is the only way to add resource under another repository group.
+  Furthermore giving non-existing path will no longer create the missing
+  structure. This change makes the api more consistent, it better validates
+  the errors in the data sent to given api call.
+- Pull requests: disable subrepo handling on pull requests. It means users can
+  now use more types of repositories with subrepos to create pull requests.
+  Since handling is disabled, repositories behind authentication, or outside
+  of network can be used.
+- VCSServer: fetch backend info from vcsserver including git/hg/svn versions
+  and connection information.
+- Svn support: it's no longer required to put in repo root path to
+  generate mod-dav-svn config. Fixes #4203.
+- Svn support: Add reload command option (svn.proxy.reload_cmd) to ini files.
+  Apache can now be automatically reloaded when the mod_dav_svn config changes.
+- Svn support: Add a view to trigger the (re)generation of Apache mod_dav_svn
+  configuration file. Users are able to generate such file manually by clicking
+  that button.
+- Dependency: updated subversion library to 1.9.
+- Dependency: updated ipython to 5.1.0.
+- Dependency: updated psutil to 4.3.1.
+
+
+Security
+^^^^^^^^
+
+- Hipchat: escape user entered data to avoid xss/formatting problems.
+- VCSServer: obfuscate credentials added into remote url during remote
+  repository creation. Prevents leaking of those credentials inside
+  RhodeCode logs.
+
+
+Performance
+^^^^^^^^^^^
+
+- Diffs: new diff engine is much smarter when it comes to showing huge diffs.
+  The rendering speed should be much improved in such cases, however showing
+  full diff is still supported.
+- VCS backends: when using a repo object from database, re-use this information
+  instead of trying to detect a backend. Reduces the traffic to vcsserver.
+- Pull requests: Add a column to hold the last merge revision. This will skip
+  heavy recalculation of merge state if nothing changed inside a pull request.
+- File source view: don't load the file if it is over the size limit since it
+  won't be displayed anyway. This increases speed of loading the page when a
+  file is above cut-off limit defined.
+
+
+Fixes
+^^^^^
+
+- Users admin: fixed search filter in user admin page.
+- Autocomplete: improve the lookup of users with non-ascii characters. In case
+  of unicode email the previous method could generate wrong data, and
+  make search not show up such users.
+- Svn: added request header downgrade for COPY command to work on
+  https setup. Fixes #4307.
+- Svn: add handling of renamed files inside our generated changes metadata.
+  Fixes #4258.
+- Pull requests: fixed problem with creating pull requests on empty repositories.
+- Events: use branch from previous commit for repo push event commits data so
+  that per-branch grouping works. Fixes #4233.
+- Login: make sure recaptcha data is always validated. Fixes #4279.
+- Vcs: Use commit date as modification time when creating archives.
+  Fixes problem with unstable hashes for archives. Fixes #4247.
+- Issue trackers: fixed bug where saving empty issue tracker via form was
+  causing exception. Fixes #4278.
+- Styling: fixed gravatar size for pull request reviewers.
+- Ldap: fixed email extraction typo. An empty email from LDAP server will now
+  not overwrite the stored one.
+- Integrations: use consistent formatting of users data in Slack integration.
+- Meta-tags: meta tags are not taken into account when truncating descriptions
+  that are too long. Fixes #4305.
  No newline at end of file

licenses/diff_match_patch_license.txt

@@ -0,0 +1,14 b''
+Copyright 2006 Google Inc.
+http://code.google.com/p/google-diff-match-patch/
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

licenses/pygments_markdown_lexer_license.txt

@@ -0,0 +1,12 b''
+    Copyright ©  2015 Jürgen Hermann <[e-mail]>
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

rhodecode/lib/codeblocks.py

@@ -0,0 +1,665 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import logging
+import difflib
+from itertools import groupby
+
+from pygments import lex
+from pygments.formatters.html import _get_ttype_class as pygment_token_class
+from rhodecode.lib.helpers import (
+    get_lexer_for_filenode, get_lexer_safe, html_escape)
+from rhodecode.lib.utils2 import AttributeDict
+from rhodecode.lib.vcs.nodes import FileNode
+from rhodecode.lib.diff_match_patch import diff_match_patch
+from rhodecode.lib.diffs import LimitedDiffContainer
+from pygments.lexers import get_lexer_by_name
+
+plain_text_lexer = get_lexer_by_name(
+    'text', stripall=False, stripnl=False, ensurenl=False)
+
+
+log = logging.getLogger()
+
+
+def filenode_as_lines_tokens(filenode, lexer=None):
+    lexer = lexer or get_lexer_for_filenode(filenode)
+    log.debug('Generating file node pygment tokens for %s, %s', lexer, filenode)
+    tokens = tokenize_string(filenode.content, lexer)
+    lines = split_token_stream(tokens, split_string='\n')
+    rv = list(lines)
+    return rv
+
+
+def tokenize_string(content, lexer):
+    """
+    Use pygments to tokenize some content based on a lexer
+    ensuring all original new lines and whitespace is preserved
+    """
+
+    lexer.stripall = False
+    lexer.stripnl = False
+    lexer.ensurenl = False
+    for token_type, token_text in lex(content, lexer):
+        yield pygment_token_class(token_type), token_text
+
+
+def split_token_stream(tokens, split_string=u'\n'):
+    """
+    Take a list of (TokenType, text) tuples and split them by a string
+
+    >>> split_token_stream([(TEXT, 'some\ntext'), (TEXT, 'more\n')])
+    [(TEXT, 'some'), (TEXT, 'text'),
+     (TEXT, 'more'), (TEXT, 'text')]
+    """
+
+    buffer = []
+    for token_class, token_text in tokens:
+        parts = token_text.split(split_string)
+        for part in parts[:-1]:
+            buffer.append((token_class, part))
+            yield buffer
+            buffer = []
+
+        buffer.append((token_class, parts[-1]))
+
+    if buffer:
+        yield buffer
+
+
+def filenode_as_annotated_lines_tokens(filenode):
+    """
+    Take a file node and return a list of annotations => lines, if no annotation
+    is found, it will be None.
+
+    eg:
+
+    [
+        (annotation1, [
+            (1, line1_tokens_list),
+            (2, line2_tokens_list),
+        ]),
+        (annotation2, [
+            (3, line1_tokens_list),
+        ]),
+        (None, [
+            (4, line1_tokens_list),
+        ]),
+        (annotation1, [
+            (5, line1_tokens_list),
+            (6, line2_tokens_list),
+        ])
+    ]
+    """
+
+    commit_cache = {} # cache commit_getter lookups
+
+    def _get_annotation(commit_id, commit_getter):
+        if commit_id not in commit_cache:
+            commit_cache[commit_id] = commit_getter()
+        return commit_cache[commit_id]
+
+    annotation_lookup = {
+        line_no: _get_annotation(commit_id, commit_getter)
+        for line_no, commit_id, commit_getter, line_content
+        in filenode.annotate
+    }
+
+    annotations_lines = ((annotation_lookup.get(line_no), line_no, tokens)
+                          for line_no, tokens
+                          in enumerate(filenode_as_lines_tokens(filenode), 1))
+
+    grouped_annotations_lines = groupby(annotations_lines, lambda x: x[0])
+
+    for annotation, group in grouped_annotations_lines:
+        yield (
+            annotation, [(line_no, tokens)
+                          for (_, line_no, tokens) in group]
+        )
+
+
+def render_tokenstream(tokenstream):
+    result = []
+    for token_class, token_ops_texts in rollup_tokenstream(tokenstream):
+
+        if token_class:
+            result.append(u'<span class="%s">' % token_class)
+        else:
+            result.append(u'<span>')
+
+        for op_tag, token_text in token_ops_texts:
+
+            if op_tag:
+                result.append(u'<%s>' % op_tag)
+
+            escaped_text = html_escape(token_text)
+
+            # TODO: dan: investigate showing hidden characters like space/nl/tab
+            # escaped_text = escaped_text.replace(' ', '<sp> </sp>')
+            # escaped_text = escaped_text.replace('\n', '<nl>\n</nl>')
+            # escaped_text = escaped_text.replace('\t', '<tab>\t</tab>')
+
+            result.append(escaped_text)
+
+            if op_tag:
+                result.append(u'</%s>' % op_tag)
+
+        result.append(u'</span>')
+
+    html = ''.join(result)
+    return html
+
+
+def rollup_tokenstream(tokenstream):
+    """
+    Group a token stream of the format:
+
+        ('class', 'op', 'text')
+    or
+        ('class', 'text')
+
+    into
+
+        [('class1',
+            [('op1', 'text'),
+             ('op2', 'text')]),
+         ('class2',
+            [('op3', 'text')])]
+
+    This is used to get the minimal tags necessary when
+    rendering to html eg for a token stream ie.
+
+    <span class="A"><ins>he</ins>llo</span>
+    vs
+    <span class="A"><ins>he</ins></span><span class="A">llo</span>
+
+    If a 2 tuple is passed in, the output op will be an empty string.
+
+    eg:
+
+    >>> rollup_tokenstream([('classA', '',      'h'),
+                            ('classA', 'del',   'ell'),
+                            ('classA', '',      'o'),
+                            ('classB', '',      ' '),
+                            ('classA', '',      'the'),
+                            ('classA', '',      're'),
+                            ])
+
+    [('classA', [('', 'h'), ('del', 'ell'), ('', 'o')],
+     ('classB', [('', ' ')],
+     ('classA', [('', 'there')]]
+
+    """
+    if tokenstream and len(tokenstream[0]) == 2:
+        tokenstream = ((t[0], '', t[1]) for t in tokenstream)
+
+    result = []
+    for token_class, op_list in groupby(tokenstream, lambda t: t[0]):
+        ops = []
+        for token_op, token_text_list in groupby(op_list, lambda o: o[1]):
+            text_buffer = []
+            for t_class, t_op, t_text in token_text_list:
+                text_buffer.append(t_text)
+            ops.append((token_op, ''.join(text_buffer)))
+        result.append((token_class, ops))
+    return result
+
+
+def tokens_diff(old_tokens, new_tokens, use_diff_match_patch=True):
+    """
+    Converts a list of (token_class, token_text) tuples to a list of
+    (token_class, token_op, token_text) tuples where token_op is one of
+    ('ins', 'del', '')
+
+    :param old_tokens: list of (token_class, token_text) tuples of old line
+    :param new_tokens: list of (token_class, token_text) tuples of new line
+    :param use_diff_match_patch: boolean, will use google's diff match patch
+        library which has options to 'smooth' out the character by character
+        differences making nicer ins/del blocks
+    """
+
+    old_tokens_result = []
+    new_tokens_result = []
+
+    similarity = difflib.SequenceMatcher(None,
+        ''.join(token_text for token_class, token_text in old_tokens),
+        ''.join(token_text for token_class, token_text in new_tokens)
+    ).ratio()
+
+    if similarity < 0.6: # return, the blocks are too different
+        for token_class, token_text in old_tokens:
+            old_tokens_result.append((token_class, '', token_text))
+        for token_class, token_text in new_tokens:
+            new_tokens_result.append((token_class, '', token_text))
+        return old_tokens_result, new_tokens_result, similarity
+
+    token_sequence_matcher = difflib.SequenceMatcher(None,
+        [x[1] for x in old_tokens],
+        [x[1] for x in new_tokens])
+
+    for tag, o1, o2, n1, n2 in token_sequence_matcher.get_opcodes():
+        # check the differences by token block types first to give a more
+        # nicer "block" level replacement vs character diffs
+
+        if tag == 'equal':
+            for token_class, token_text in old_tokens[o1:o2]:
+                old_tokens_result.append((token_class, '', token_text))
+            for token_class, token_text in new_tokens[n1:n2]:
+                new_tokens_result.append((token_class, '', token_text))
+        elif tag == 'delete':
+            for token_class, token_text in old_tokens[o1:o2]:
+                old_tokens_result.append((token_class, 'del', token_text))
+        elif tag == 'insert':
+            for token_class, token_text in new_tokens[n1:n2]:
+                new_tokens_result.append((token_class, 'ins', token_text))
+        elif tag == 'replace':
+            # if same type token blocks must be replaced, do a diff on the
+            # characters in the token blocks to show individual changes
+
+            old_char_tokens = []
+            new_char_tokens = []
+            for token_class, token_text in old_tokens[o1:o2]:
+                for char in token_text:
+                    old_char_tokens.append((token_class, char))
+
+            for token_class, token_text in new_tokens[n1:n2]:
+                for char in token_text:
+                    new_char_tokens.append((token_class, char))
+
+            old_string = ''.join([token_text for
+                token_class, token_text in old_char_tokens])
+            new_string = ''.join([token_text for
+                token_class, token_text in new_char_tokens])
+
+            char_sequence = difflib.SequenceMatcher(
+                None, old_string, new_string)
+            copcodes = char_sequence.get_opcodes()
+            obuffer, nbuffer = [], []
+
+            if use_diff_match_patch:
+                dmp = diff_match_patch()
+                dmp.Diff_EditCost = 11 # TODO: dan: extract this to a setting
+                reps = dmp.diff_main(old_string, new_string)
+                dmp.diff_cleanupEfficiency(reps)
+
+                a, b = 0, 0
+                for op, rep in reps:
+                    l = len(rep)
+                    if op == 0:
+                        for i, c in enumerate(rep):
+                            obuffer.append((old_char_tokens[a+i][0], '', c))
+                            nbuffer.append((new_char_tokens[b+i][0], '', c))
+                        a += l
+                        b += l
+                    elif op == -1:
+                        for i, c in enumerate(rep):
+                            obuffer.append((old_char_tokens[a+i][0], 'del', c))
+                        a += l
+                    elif op == 1:
+                        for i, c in enumerate(rep):
+                            nbuffer.append((new_char_tokens[b+i][0], 'ins', c))
+                        b += l
+            else:
+                for ctag, co1, co2, cn1, cn2 in copcodes:
+                    if ctag == 'equal':
+                        for token_class, token_text in old_char_tokens[co1:co2]:
+                            obuffer.append((token_class, '', token_text))
+                        for token_class, token_text in new_char_tokens[cn1:cn2]:
+                            nbuffer.append((token_class, '', token_text))
+                    elif ctag == 'delete':
+                        for token_class, token_text in old_char_tokens[co1:co2]:
+                            obuffer.append((token_class, 'del', token_text))
+                    elif ctag == 'insert':
+                        for token_class, token_text in new_char_tokens[cn1:cn2]:
+                            nbuffer.append((token_class, 'ins', token_text))
+                    elif ctag == 'replace':
+                        for token_class, token_text in old_char_tokens[co1:co2]:
+                            obuffer.append((token_class, 'del', token_text))
+                        for token_class, token_text in new_char_tokens[cn1:cn2]:
+                            nbuffer.append((token_class, 'ins', token_text))
+
+            old_tokens_result.extend(obuffer)
+            new_tokens_result.extend(nbuffer)
+
+    return old_tokens_result, new_tokens_result, similarity
+
+
+class DiffSet(object):
+    """
+    An object for parsing the diff result from diffs.DiffProcessor and
+    adding highlighting, side by side/unified renderings and line diffs
+    """
+
+    HL_REAL = 'REAL' # highlights using original file, slow
+    HL_FAST = 'FAST' # highlights using just the line, fast but not correct
+                     # in the case of multiline code
+    HL_NONE = 'NONE' # no highlighting, fastest
+
+    def __init__(self, highlight_mode=HL_REAL, repo_name=None,
+                 source_node_getter=lambda filename: None,
+                 target_node_getter=lambda filename: None,
+                 source_nodes=None, target_nodes=None,
+                 max_file_size_limit=150 * 1024, # files over this size will
+                                                 # use fast highlighting
+                 comments=None,
+                 ):
+
+        self.highlight_mode = highlight_mode
+        self.highlighted_filenodes = {}
+        self.source_node_getter = source_node_getter
+        self.target_node_getter = target_node_getter
+        self.source_nodes = source_nodes or {}
+        self.target_nodes = target_nodes or {}
+        self.repo_name = repo_name
+        self.comments = comments or {}
+        self.max_file_size_limit = max_file_size_limit
+
+    def render_patchset(self, patchset, source_ref=None, target_ref=None):
+        diffset = AttributeDict(dict(
+            lines_added=0,
+            lines_deleted=0,
+            changed_files=0,
+            files=[],
+            limited_diff=isinstance(patchset, LimitedDiffContainer),
+            repo_name=self.repo_name,
+            source_ref=source_ref,
+            target_ref=target_ref,
+        ))
+        for patch in patchset:
+            filediff = self.render_patch(patch)
+            filediff.diffset = diffset
+            diffset.files.append(filediff)
+            diffset.changed_files += 1
+            if not patch['stats']['binary']:
+                diffset.lines_added += patch['stats']['added']
+                diffset.lines_deleted += patch['stats']['deleted']
+
+        return diffset
+
+    _lexer_cache = {}
+    def _get_lexer_for_filename(self, filename):
+        # cached because we might need to call it twice for source/target
+        if filename not in self._lexer_cache:
+            self._lexer_cache[filename] = get_lexer_safe(filepath=filename)
+        return self._lexer_cache[filename]
+
+    def render_patch(self, patch):
+        log.debug('rendering diff for %r' % patch['filename'])
+
+        source_filename = patch['original_filename']
+        target_filename = patch['filename']
+
+        source_lexer = plain_text_lexer
+        target_lexer = plain_text_lexer
+
+        if not patch['stats']['binary']:
+            if self.highlight_mode == self.HL_REAL:
+                if (source_filename and patch['operation'] in ('D', 'M')
+                    and source_filename not in self.source_nodes):
+                        self.source_nodes[source_filename] = (
+                            self.source_node_getter(source_filename))
+
+                if (target_filename and patch['operation'] in ('A', 'M')
+                    and target_filename not in self.target_nodes):
+                        self.target_nodes[target_filename] = (
+                            self.target_node_getter(target_filename))
+
+            elif self.highlight_mode == self.HL_FAST:
+                source_lexer = self._get_lexer_for_filename(source_filename)
+                target_lexer = self._get_lexer_for_filename(target_filename)
+
+        source_file = self.source_nodes.get(source_filename, source_filename)
+        target_file = self.target_nodes.get(target_filename, target_filename)
+
+        source_filenode, target_filenode = None, None
+
+        # TODO: dan: FileNode.lexer works on the content of the file - which
+        # can be slow - issue #4289 explains a lexer clean up - which once
+        # done can allow caching a lexer for a filenode to avoid the file lookup
+        if isinstance(source_file, FileNode):
+            source_filenode = source_file
+            source_lexer = source_file.lexer
+        if isinstance(target_file, FileNode):
+            target_filenode = target_file
+            target_lexer = target_file.lexer
+
+        source_file_path, target_file_path = None, None
+
+        if source_filename != '/dev/null':
+            source_file_path = source_filename
+        if target_filename != '/dev/null':
+            target_file_path = target_filename
+
+        source_file_type = source_lexer.name
+        target_file_type = target_lexer.name
+
+        op_hunks = patch['chunks'][0]
+        hunks = patch['chunks'][1:]
+
+        filediff = AttributeDict({
+            'source_file_path': source_file_path,
+            'target_file_path': target_file_path,
+            'source_filenode': source_filenode,
+            'target_filenode': target_filenode,
+            'hunks': [],
+            'source_file_type': target_file_type,
+            'target_file_type': source_file_type,
+            'patch': patch,
+            'source_mode': patch['stats']['old_mode'],
+            'target_mode': patch['stats']['new_mode'],
+            'limited_diff': isinstance(patch, LimitedDiffContainer),
+            'diffset': self,
+        })
+
+        for hunk in hunks:
+            hunkbit = self.parse_hunk(hunk, source_file, target_file)
+            hunkbit.filediff = filediff
+            filediff.hunks.append(hunkbit)
+        return filediff
+
+    def parse_hunk(self, hunk, source_file, target_file):
+        result = AttributeDict(dict(
+            source_start=hunk['source_start'],
+            source_length=hunk['source_length'],
+            target_start=hunk['target_start'],
+            target_length=hunk['target_length'],
+            section_header=hunk['section_header'],
+            lines=[],
+        ))
+        before, after = [], []
+
+        for line in hunk['lines']:
+            if line['action'] == 'unmod':
+                result.lines.extend(
+                    self.parse_lines(before, after, source_file, target_file))
+                after.append(line)
+                before.append(line)
+            elif line['action'] == 'add':
+                after.append(line)
+            elif line['action'] == 'del':
+                before.append(line)
+            elif line['action'] == 'old-no-nl':
+                before.append(line)
+            elif line['action'] == 'new-no-nl':
+                after.append(line)
+
+        result.lines.extend(
+            self.parse_lines(before, after, source_file, target_file))
+        result.unified = self.as_unified(result.lines)
+        result.sideside = result.lines
+        return result
+
+    def parse_lines(self, before_lines, after_lines, source_file, target_file):
+        # TODO: dan: investigate doing the diff comparison and fast highlighting
+        # on the entire before and after buffered block lines rather than by
+        # line, this means we can get better 'fast' highlighting if the context
+        # allows it - eg.
+        # line 4: """
+        # line 5: this gets highlighted as a string
+        # line 6: """
+
+        lines = []
+        while before_lines or after_lines:
+            before, after = None, None
+            before_tokens, after_tokens = None, None
+
+            if before_lines:
+                before = before_lines.pop(0)
+            if after_lines:
+                after = after_lines.pop(0)
+
+            original = AttributeDict()
+            modified = AttributeDict()
+
+            if before:
+                if before['action'] == 'old-no-nl':
+                    before_tokens = [('nonl', before['line'])]
+                else:
+                    before_tokens = self.get_line_tokens(
+                        line_text=before['line'], line_number=before['old_lineno'],
+                        file=source_file)
+                original.lineno = before['old_lineno']
+                original.content = before['line']
+                original.action = self.action_to_op(before['action'])
+                original.comments = self.get_comments_for('old',
+                    source_file, before['old_lineno'])
+
+            if after:
+                if after['action'] == 'new-no-nl':
+                    after_tokens = [('nonl', after['line'])]
+                else:
+                    after_tokens = self.get_line_tokens(
+                        line_text=after['line'], line_number=after['new_lineno'],
+                        file=target_file)
+                modified.lineno = after['new_lineno']
+                modified.content = after['line']
+                modified.action = self.action_to_op(after['action'])
+                modified.comments = self.get_comments_for('new',
+                    target_file, after['new_lineno'])
+
+            # diff the lines
+            if before_tokens and after_tokens:
+                o_tokens, m_tokens, similarity = tokens_diff(
+                    before_tokens, after_tokens)
+                original.content = render_tokenstream(o_tokens)
+                modified.content = render_tokenstream(m_tokens)
+            elif before_tokens:
+                original.content = render_tokenstream(
+                    [(x[0], '', x[1]) for x in before_tokens])
+            elif after_tokens:
+                modified.content = render_tokenstream(
+                    [(x[0], '', x[1]) for x in after_tokens])
+
+            lines.append(AttributeDict({
+                'original': original,
+                'modified': modified,
+            }))
+
+        return lines
+
+    def get_comments_for(self, version, file, line_number):
+        if hasattr(file, 'unicode_path'):
+            file = file.unicode_path
+
+        if not isinstance(file, basestring):
+            return None
+
+        line_key = {
+            'old': 'o',
+            'new': 'n',
+        }[version] + str(line_number)
+
+        return self.comments.get(file, {}).get(line_key)
+
+    def get_line_tokens(self, line_text, line_number, file=None):
+        filenode = None
+        filename = None
+
+        if isinstance(file, basestring):
+            filename = file
+        elif isinstance(file, FileNode):
+            filenode = file
+            filename = file.unicode_path
+
+        if self.highlight_mode == self.HL_REAL and filenode:
+            if line_number and file.size < self.max_file_size_limit:
+                return self.get_tokenized_filenode_line(file, line_number)
+
+        if self.highlight_mode in (self.HL_REAL, self.HL_FAST) and filename:
+            lexer = self._get_lexer_for_filename(filename)
+            return list(tokenize_string(line_text, lexer))
+
+        return list(tokenize_string(line_text, plain_text_lexer))
+
+    def get_tokenized_filenode_line(self, filenode, line_number):
+
+        if filenode not in self.highlighted_filenodes:
+            tokenized_lines = filenode_as_lines_tokens(filenode, filenode.lexer)
+            self.highlighted_filenodes[filenode] = tokenized_lines
+        return self.highlighted_filenodes[filenode][line_number - 1]
+
+    def action_to_op(self, action):
+        return {
+            'add': '+',
+            'del': '-',
+            'unmod': ' ',
+            'old-no-nl': ' ',
+            'new-no-nl': ' ',
+        }.get(action, action)
+
+    def as_unified(self, lines):
+        """ Return a generator that yields the lines of a diff in unified order """
+        def generator():
+            buf = []
+            for line in lines:
+
+                if buf and not line.original or line.original.action == ' ':
+                    for b in buf:
+                        yield b
+                    buf = []
+
+                if line.original:
+                    if line.original.action == ' ':
+                        yield (line.original.lineno, line.modified.lineno,
+                               line.original.action, line.original.content,
+                               line.original.comments)
+                        continue
+
+                    if line.original.action == '-':
+                        yield (line.original.lineno, None,
+                               line.original.action, line.original.content,
+                               line.original.comments)
+
+                    if line.modified.action == '+':
+                        buf.append((
+                            None, line.modified.lineno,
+                            line.modified.action, line.modified.content,
+                            line.modified.comments))
+                        continue
+
+                if line.modified:
+                    yield (None, line.modified.lineno,
+                           line.modified.action, line.modified.content,
+                           line.modified.comments)
+
+            for b in buf:
+                yield b
+
+        return generator()

rhodecode/lib/dbmigrate/schema/db_4_4_0_2.py

@@ -0,0 +1,3640 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+"""
+Database Models for RhodeCode Enterprise
+"""
+
+import re
+import os
+import sys
+import time
+import hashlib
+import logging
+import datetime
+import warnings
+import ipaddress
+import functools
+import traceback
+import collections
+
+
+from sqlalchemy import *
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.orm import (
+    relationship, joinedload, class_mapper, validates, aliased)
+from sqlalchemy.sql.expression import true
+from beaker.cache import cache_region, region_invalidate
+from webob.exc import HTTPNotFound
+from zope.cachedescriptors.property import Lazy as LazyProperty
+
+from pylons import url
+from pylons.i18n.translation import lazy_ugettext as _
+
+from rhodecode.lib.vcs import get_backend, get_vcs_instance
+from rhodecode.lib.vcs.utils.helpers import get_scm
+from rhodecode.lib.vcs.exceptions import VCSError
+from rhodecode.lib.vcs.backends.base import (
+    EmptyCommit, Reference, MergeFailureReason)
+from rhodecode.lib.utils2 import (
+    str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,
+    time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
+    glob2re)
+from rhodecode.lib.jsonalchemy import MutationObj, JsonType, JSONDict
+from rhodecode.lib.ext_json import json
+from rhodecode.lib.caching_query import FromCache
+from rhodecode.lib.encrypt import AESCipher
+
+from rhodecode.model.meta import Base, Session
+
+URL_SEP = '/'
+log = logging.getLogger(__name__)
+
+# =============================================================================
+# BASE CLASSES
+# =============================================================================
+
+# this is propagated from .ini file rhodecode.encrypted_values.secret or
+# beaker.session.secret if first is not set.
+# and initialized at environment.py
+ENCRYPTION_KEY = None
+
+# used to sort permissions by types, '#' used here is not allowed to be in
+# usernames, and it's very early in sorted string.printable table.
+PERMISSION_TYPE_SORT = {
+    'admin': '####',
+    'write': '###',
+    'read':  '##',
+    'none':  '#',
+}
+
+
+def display_sort(obj):
+    """
+    Sort function used to sort permissions in .permissions() function of
+    Repository, RepoGroup, UserGroup. Also it put the default user in front
+    of all other resources
+    """
+
+    if obj.username == User.DEFAULT_USER:
+        return '#####'
+    prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
+    return prefix + obj.username
+
+
+def _hash_key(k):
+    return md5_safe(k)
+
+
+class EncryptedTextValue(TypeDecorator):
+    """
+    Special column for encrypted long text data, use like::
+
+        value = Column("encrypted_value", EncryptedValue(), nullable=False)
+
+    This column is intelligent so if value is in unencrypted form it return
+    unencrypted form, but on save it always encrypts
+    """
+    impl = Text
+
+    def process_bind_param(self, value, dialect):
+        if not value:
+            return value
+        if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
+            # protect against double encrypting if someone manually starts
+            # doing
+            raise ValueError('value needs to be in unencrypted format, ie. '
+                             'not starting with enc$aes')
+        return 'enc$aes_hmac$%s' % AESCipher(
+            ENCRYPTION_KEY, hmac=True).encrypt(value)
+
+    def process_result_value(self, value, dialect):
+        import rhodecode
+
+        if not value:
+            return value
+
+        parts = value.split('$', 3)
+        if not len(parts) == 3:
+            # probably not encrypted values
+            return value
+        else:
+            if parts[0] != 'enc':
+                # parts ok but without our header ?
+                return value
+            enc_strict_mode = str2bool(rhodecode.CONFIG.get(
+                'rhodecode.encrypted_values.strict') or True)
+            # at that stage we know it's our encryption
+            if parts[1] == 'aes':
+                decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
+            elif parts[1] == 'aes_hmac':
+                decrypted_data = AESCipher(
+                    ENCRYPTION_KEY, hmac=True,
+                    strict_verification=enc_strict_mode).decrypt(parts[2])
+            else:
+                raise ValueError(
+                    'Encryption type part is wrong, must be `aes` '
+                    'or `aes_hmac`, got `%s` instead' % (parts[1]))
+            return decrypted_data
+
+
+class BaseModel(object):
+    """
+    Base Model for all classes
+    """
+
+    @classmethod
+    def _get_keys(cls):
+        """return column names for this model """
+        return class_mapper(cls).c.keys()
+
+    def get_dict(self):
+        """
+        return dict with keys and values corresponding
+        to this model data """
+
+        d = {}
+        for k in self._get_keys():
+            d[k] = getattr(self, k)
+
+        # also use __json__() if present to get additional fields
+        _json_attr = getattr(self, '__json__', None)
+        if _json_attr:
+            # update with attributes from __json__
+            if callable(_json_attr):
+                _json_attr = _json_attr()
+            for k, val in _json_attr.iteritems():
+                d[k] = val
+        return d
+
+    def get_appstruct(self):
+        """return list with keys and values tuples corresponding
+        to this model data """
+
+        l = []
+        for k in self._get_keys():
+            l.append((k, getattr(self, k),))
+        return l
+
+    def populate_obj(self, populate_dict):
+        """populate model with data from given populate_dict"""
+
+        for k in self._get_keys():
+            if k in populate_dict:
+                setattr(self, k, populate_dict[k])
+
+    @classmethod
+    def query(cls):
+        return Session().query(cls)
+
+    @classmethod
+    def get(cls, id_):
+        if id_:
+            return cls.query().get(id_)
+
+    @classmethod
+    def get_or_404(cls, id_):
+        try:
+            id_ = int(id_)
+        except (TypeError, ValueError):
+            raise HTTPNotFound
+
+        res = cls.query().get(id_)
+        if not res:
+            raise HTTPNotFound
+        return res
+
+    @classmethod
+    def getAll(cls):
+        # deprecated and left for backward compatibility
+        return cls.get_all()
+
+    @classmethod
+    def get_all(cls):
+        return cls.query().all()
+
+    @classmethod
+    def delete(cls, id_):
+        obj = cls.query().get(id_)
+        Session().delete(obj)
+
+    @classmethod
+    def identity_cache(cls, session, attr_name, value):
+        exist_in_session = []
+        for (item_cls, pkey), instance in session.identity_map.items():
+            if cls == item_cls and getattr(instance, attr_name) == value:
+                exist_in_session.append(instance)
+        if exist_in_session:
+            if len(exist_in_session) == 1:
+                return exist_in_session[0]
+            log.exception(
+                'multiple objects with attr %s and '
+                'value %s found with same name: %r',
+                attr_name, value, exist_in_session)
+
+    def __repr__(self):
+        if hasattr(self, '__unicode__'):
+            # python repr needs to return str
+            try:
+                return safe_str(self.__unicode__())
+            except UnicodeDecodeError:
+                pass
+        return '<DB:%s>' % (self.__class__.__name__)
+
+
+class RhodeCodeSetting(Base, BaseModel):
+    __tablename__ = 'rhodecode_settings'
+    __table_args__ = (
+        UniqueConstraint('app_settings_name'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    SETTINGS_TYPES = {
+        'str': safe_str,
+        'int': safe_int,
+        'unicode': safe_unicode,
+        'bool': str2bool,
+        'list': functools.partial(aslist, sep=',')
+    }
+    DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
+    GLOBAL_CONF_KEY = 'app_settings'
+
+    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
+    _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
+    _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
+
+    def __init__(self, key='', val='', type='unicode'):
+        self.app_settings_name = key
+        self.app_settings_type = type
+        self.app_settings_value = val
+
+    @validates('_app_settings_value')
+    def validate_settings_value(self, key, val):
+        assert type(val) == unicode
+        return val
+
+    @hybrid_property
+    def app_settings_value(self):
+        v = self._app_settings_value
+        _type = self.app_settings_type
+        if _type:
+            _type = self.app_settings_type.split('.')[0]
+            # decode the encrypted value
+            if 'encrypted' in self.app_settings_type:
+                cipher = EncryptedTextValue()
+                v = safe_unicode(cipher.process_result_value(v, None))
+
+        converter = self.SETTINGS_TYPES.get(_type) or \
+            self.SETTINGS_TYPES['unicode']
+        return converter(v)
+
+    @app_settings_value.setter
+    def app_settings_value(self, val):
+        """
+        Setter that will always make sure we use unicode in app_settings_value
+
+        :param val:
+        """
+        val = safe_unicode(val)
+        # encode the encrypted value
+        if 'encrypted' in self.app_settings_type:
+            cipher = EncryptedTextValue()
+            val = safe_unicode(cipher.process_bind_param(val, None))
+        self._app_settings_value = val
+
+    @hybrid_property
+    def app_settings_type(self):
+        return self._app_settings_type
+
+    @app_settings_type.setter
+    def app_settings_type(self, val):
+        if val.split('.')[0] not in self.SETTINGS_TYPES:
+            raise Exception('type must be one of %s got %s'
+                            % (self.SETTINGS_TYPES.keys(), val))
+        self._app_settings_type = val
+
+    def __unicode__(self):
+        return u"<%s('%s:%s[%s]')>" % (
+            self.__class__.__name__,
+            self.app_settings_name, self.app_settings_value,
+            self.app_settings_type
+        )
+
+
+class RhodeCodeUi(Base, BaseModel):
+    __tablename__ = 'rhodecode_ui'
+    __table_args__ = (
+        UniqueConstraint('ui_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    HOOK_REPO_SIZE = 'changegroup.repo_size'
+    # HG
+    HOOK_PRE_PULL = 'preoutgoing.pre_pull'
+    HOOK_PULL = 'outgoing.pull_logger'
+    HOOK_PRE_PUSH = 'prechangegroup.pre_push'
+    HOOK_PUSH = 'changegroup.push_logger'
+
+    # TODO: johbo: Unify way how hooks are configured for git and hg,
+    # git part is currently hardcoded.
+
+    # SVN PATTERNS
+    SVN_BRANCH_ID = 'vcs_svn_branch'
+    SVN_TAG_ID = 'vcs_svn_tag'
+
+    ui_id = Column(
+        "ui_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    ui_section = Column(
+        "ui_section", String(255), nullable=True, unique=None, default=None)
+    ui_key = Column(
+        "ui_key", String(255), nullable=True, unique=None, default=None)
+    ui_value = Column(
+        "ui_value", String(255), nullable=True, unique=None, default=None)
+    ui_active = Column(
+        "ui_active", Boolean(), nullable=True, unique=None, default=True)
+
+    def __repr__(self):
+        return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
+                                    self.ui_key, self.ui_value)
+
+
+class RepoRhodeCodeSetting(Base, BaseModel):
+    __tablename__ = 'repo_rhodecode_settings'
+    __table_args__ = (
+        UniqueConstraint(
+            'app_settings_name', 'repository_id',
+            name='uq_repo_rhodecode_setting_name_repo_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    repository_id = Column(
+        "repository_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=False)
+    app_settings_id = Column(
+        "app_settings_id", Integer(), nullable=False, unique=True,
+        default=None, primary_key=True)
+    app_settings_name = Column(
+        "app_settings_name", String(255), nullable=True, unique=None,
+        default=None)
+    _app_settings_value = Column(
+        "app_settings_value", String(4096), nullable=True, unique=None,
+        default=None)
+    _app_settings_type = Column(
+        "app_settings_type", String(255), nullable=True, unique=None,
+        default=None)
+
+    repository = relationship('Repository')
+
+    def __init__(self, repository_id, key='', val='', type='unicode'):
+        self.repository_id = repository_id
+        self.app_settings_name = key
+        self.app_settings_type = type
+        self.app_settings_value = val
+
+    @validates('_app_settings_value')
+    def validate_settings_value(self, key, val):
+        assert type(val) == unicode
+        return val
+
+    @hybrid_property
+    def app_settings_value(self):
+        v = self._app_settings_value
+        type_ = self.app_settings_type
+        SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
+        converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
+        return converter(v)
+
+    @app_settings_value.setter
+    def app_settings_value(self, val):
+        """
+        Setter that will always make sure we use unicode in app_settings_value
+
+        :param val:
+        """
+        self._app_settings_value = safe_unicode(val)
+
+    @hybrid_property
+    def app_settings_type(self):
+        return self._app_settings_type
+
+    @app_settings_type.setter
+    def app_settings_type(self, val):
+        SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
+        if val not in SETTINGS_TYPES:
+            raise Exception('type must be one of %s got %s'
+                            % (SETTINGS_TYPES.keys(), val))
+        self._app_settings_type = val
+
+    def __unicode__(self):
+        return u"<%s('%s:%s:%s[%s]')>" % (
+            self.__class__.__name__, self.repository.repo_name,
+            self.app_settings_name, self.app_settings_value,
+            self.app_settings_type
+        )
+
+
+class RepoRhodeCodeUi(Base, BaseModel):
+    __tablename__ = 'repo_rhodecode_ui'
+    __table_args__ = (
+        UniqueConstraint(
+            'repository_id', 'ui_section', 'ui_key',
+            name='uq_repo_rhodecode_ui_repository_id_section_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    repository_id = Column(
+        "repository_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=False)
+    ui_id = Column(
+        "ui_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    ui_section = Column(
+        "ui_section", String(255), nullable=True, unique=None, default=None)
+    ui_key = Column(
+        "ui_key", String(255), nullable=True, unique=None, default=None)
+    ui_value = Column(
+        "ui_value", String(255), nullable=True, unique=None, default=None)
+    ui_active = Column(
+        "ui_active", Boolean(), nullable=True, unique=None, default=True)
+
+    repository = relationship('Repository')
+
+    def __repr__(self):
+        return '<%s[%s:%s]%s=>%s]>' % (
+            self.__class__.__name__, self.repository.repo_name,
+            self.ui_section, self.ui_key, self.ui_value)
+
+
+class User(Base, BaseModel):
+    __tablename__ = 'users'
+    __table_args__ = (
+        UniqueConstraint('username'), UniqueConstraint('email'),
+        Index('u_username_idx', 'username'),
+        Index('u_email_idx', 'email'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    DEFAULT_USER = 'default'
+    DEFAULT_USER_EMAIL = '[e-mail]'
+    DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
+
+    user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    username = Column("username", String(255), nullable=True, unique=None, default=None)
+    password = Column("password", String(255), nullable=True, unique=None, default=None)
+    active = Column("active", Boolean(), nullable=True, unique=None, default=True)
+    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
+    name = Column("firstname", String(255), nullable=True, unique=None, default=None)
+    lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
+    _email = Column("email", String(255), nullable=True, unique=None, default=None)
+    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
+    extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
+    extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
+    api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
+    inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
+
+    user_log = relationship('UserLog')
+    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
+
+    repositories = relationship('Repository')
+    repository_groups = relationship('RepoGroup')
+    user_groups = relationship('UserGroup')
+
+    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
+    followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
+
+    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
+    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
+    user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
+
+    group_member = relationship('UserGroupMember', cascade='all')
+
+    notifications = relationship('UserNotification', cascade='all')
+    # notifications assigned to this user
+    user_created_notifications = relationship('Notification', cascade='all')
+    # comments created by this user
+    user_comments = relationship('ChangesetComment', cascade='all')
+    # user profile extra info
+    user_emails = relationship('UserEmailMap', cascade='all')
+    user_ip_map = relationship('UserIpMap', cascade='all')
+    user_auth_tokens = relationship('UserApiKeys', cascade='all')
+    # gists
+    user_gists = relationship('Gist', cascade='all')
+    # user pull requests
+    user_pull_requests = relationship('PullRequest', cascade='all')
+    # external identities
+    extenal_identities = relationship(
+        'ExternalIdentity',
+        primaryjoin="User.user_id==ExternalIdentity.local_user_id",
+        cascade='all')
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.user_id, self.username)
+
+    @hybrid_property
+    def email(self):
+        return self._email
+
+    @email.setter
+    def email(self, val):
+        self._email = val.lower() if val else None
+
+    @property
+    def firstname(self):
+        # alias for future
+        return self.name
+
+    @property
+    def emails(self):
+        other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
+        return [self.email] + [x.email for x in other]
+
+    @property
+    def auth_tokens(self):
+        return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
+
+    @property
+    def extra_auth_tokens(self):
+        return UserApiKeys.query().filter(UserApiKeys.user == self).all()
+
+    @property
+    def feed_token(self):
+        feed_tokens = UserApiKeys.query()\
+            .filter(UserApiKeys.user == self)\
+            .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
+            .all()
+        if feed_tokens:
+            return feed_tokens[0].api_key
+        else:
+            # use the main token so we don't end up with nothing...
+            return self.api_key
+
+    @classmethod
+    def extra_valid_auth_tokens(cls, user, role=None):
+        tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
+                .filter(or_(UserApiKeys.expires == -1,
+                            UserApiKeys.expires >= time.time()))
+        if role:
+            tokens = tokens.filter(or_(UserApiKeys.role == role,
+                                       UserApiKeys.role == UserApiKeys.ROLE_ALL))
+        return tokens.all()
+
+    @property
+    def ip_addresses(self):
+        ret = UserIpMap.query().filter(UserIpMap.user == self).all()
+        return [x.ip_addr for x in ret]
+
+    @property
+    def username_and_name(self):
+        return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
+
+    @property
+    def username_or_name_or_email(self):
+        full_name = self.full_name if self.full_name is not ' ' else None
+        return self.username or full_name or self.email
+
+    @property
+    def full_name(self):
+        return '%s %s' % (self.firstname, self.lastname)
+
+    @property
+    def full_name_or_username(self):
+        return ('%s %s' % (self.firstname, self.lastname)
+                if (self.firstname and self.lastname) else self.username)
+
+    @property
+    def full_contact(self):
+        return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
+
+    @property
+    def short_contact(self):
+        return '%s %s' % (self.firstname, self.lastname)
+
+    @property
+    def is_admin(self):
+        return self.admin
+
+    @property
+    def AuthUser(self):
+        """
+        Returns instance of AuthUser for this user
+        """
+        from rhodecode.lib.auth import AuthUser
+        return AuthUser(user_id=self.user_id, api_key=self.api_key,
+                        username=self.username)
+
+    @hybrid_property
+    def user_data(self):
+        if not self._user_data:
+            return {}
+
+        try:
+            return json.loads(self._user_data)
+        except TypeError:
+            return {}
+
+    @user_data.setter
+    def user_data(self, val):
+        if not isinstance(val, dict):
+            raise Exception('user_data must be dict, got %s' % type(val))
+        try:
+            self._user_data = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    @classmethod
+    def get_by_username(cls, username, case_insensitive=False,
+                        cache=False, identity_cache=False):
+        session = Session()
+
+        if case_insensitive:
+            q = cls.query().filter(
+                func.lower(cls.username) == func.lower(username))
+        else:
+            q = cls.query().filter(cls.username == username)
+
+        if cache:
+            if identity_cache:
+                val = cls.identity_cache(session, 'username', username)
+                if val:
+                    return val
+            else:
+                q = q.options(
+                    FromCache("sql_cache_short",
+                              "get_user_by_name_%s" % _hash_key(username)))
+
+        return q.scalar()
+
+    @classmethod
+    def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
+        q = cls.query().filter(cls.api_key == auth_token)
+
+        if cache:
+            q = q.options(FromCache("sql_cache_short",
+                                    "get_auth_token_%s" % auth_token))
+        res = q.scalar()
+
+        if fallback and not res:
+            #fallback to additional keys
+            _res = UserApiKeys.query()\
+                .filter(UserApiKeys.api_key == auth_token)\
+                .filter(or_(UserApiKeys.expires == -1,
+                            UserApiKeys.expires >= time.time()))\
+                .first()
+            if _res:
+                res = _res.user
+        return res
+
+    @classmethod
+    def get_by_email(cls, email, case_insensitive=False, cache=False):
+
+        if case_insensitive:
+            q = cls.query().filter(func.lower(cls.email) == func.lower(email))
+
+        else:
+            q = cls.query().filter(cls.email == email)
+
+        if cache:
+            q = q.options(FromCache("sql_cache_short",
+                                    "get_email_key_%s" % _hash_key(email)))
+
+        ret = q.scalar()
+        if ret is None:
+            q = UserEmailMap.query()
+            # try fetching in alternate email map
+            if case_insensitive:
+                q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
+            else:
+                q = q.filter(UserEmailMap.email == email)
+            q = q.options(joinedload(UserEmailMap.user))
+            if cache:
+                q = q.options(FromCache("sql_cache_short",
+                                        "get_email_map_key_%s" % email))
+            ret = getattr(q.scalar(), 'user', None)
+
+        return ret
+
+    @classmethod
+    def get_from_cs_author(cls, author):
+        """
+        Tries to get User objects out of commit author string
+
+        :param author:
+        """
+        from rhodecode.lib.helpers import email, author_name
+        # Valid email in the attribute passed, see if they're in the system
+        _email = email(author)
+        if _email:
+            user = cls.get_by_email(_email, case_insensitive=True)
+            if user:
+                return user
+        # Maybe we can match by username?
+        _author = author_name(author)
+        user = cls.get_by_username(_author, case_insensitive=True)
+        if user:
+            return user
+
+    def update_userdata(self, **kwargs):
+        usr = self
+        old = usr.user_data
+        old.update(**kwargs)
+        usr.user_data = old
+        Session().add(usr)
+        log.debug('updated userdata with ', kwargs)
+
+    def update_lastlogin(self):
+        """Update user lastlogin"""
+        self.last_login = datetime.datetime.now()
+        Session().add(self)
+        log.debug('updated user %s lastlogin', self.username)
+
+    def update_lastactivity(self):
+        """Update user lastactivity"""
+        usr = self
+        old = usr.user_data
+        old.update({'last_activity': time.time()})
+        usr.user_data = old
+        Session().add(usr)
+        log.debug('updated user %s lastactivity', usr.username)
+
+    def update_password(self, new_password, change_api_key=False):
+        from rhodecode.lib.auth import get_crypt_password,generate_auth_token
+
+        self.password = get_crypt_password(new_password)
+        if change_api_key:
+            self.api_key = generate_auth_token(self.username)
+        Session().add(self)
+
+    @classmethod
+    def get_first_super_admin(cls):
+        user = User.query().filter(User.admin == true()).first()
+        if user is None:
+            raise Exception('FATAL: Missing administrative account!')
+        return user
+
+    @classmethod
+    def get_all_super_admins(cls):
+        """
+        Returns all admin accounts sorted by username
+        """
+        return User.query().filter(User.admin == true())\
+            .order_by(User.username.asc()).all()
+
+    @classmethod
+    def get_default_user(cls, cache=False):
+        user = User.get_by_username(User.DEFAULT_USER, cache=cache)
+        if user is None:
+            raise Exception('FATAL: Missing default account!')
+        return user
+
+    def _get_default_perms(self, user, suffix=''):
+        from rhodecode.model.permission import PermissionModel
+        return PermissionModel().get_default_perms(user.user_perms, suffix)
+
+    def get_default_perms(self, suffix=''):
+        return self._get_default_perms(self, suffix)
+
+    def get_api_data(self, include_secrets=False, details='full'):
+        """
+        Common function for generating user related data for API
+
+        :param include_secrets: By default secrets in the API data will be replaced
+           by a placeholder value to prevent exposing this data by accident. In case
+           this data shall be exposed, set this flag to ``True``.
+
+        :param details: details can be 'basic|full' basic gives only a subset of
+           the available user information that includes user_id, name and emails.
+        """
+        user = self
+        user_data = self.user_data
+        data = {
+            'user_id': user.user_id,
+            'username': user.username,
+            'firstname': user.name,
+            'lastname': user.lastname,
+            'email': user.email,
+            'emails': user.emails,
+        }
+        if details == 'basic':
+            return data
+
+        api_key_length = 40
+        api_key_replacement = '*' * api_key_length
+
+        extras = {
+            'api_key': api_key_replacement,
+            'api_keys': [api_key_replacement],
+            'active': user.active,
+            'admin': user.admin,
+            'extern_type': user.extern_type,
+            'extern_name': user.extern_name,
+            'last_login': user.last_login,
+            'ip_addresses': user.ip_addresses,
+            'language': user_data.get('language')
+        }
+        data.update(extras)
+
+        if include_secrets:
+            data['api_key'] = user.api_key
+            data['api_keys'] = user.auth_tokens
+        return data
+
+    def __json__(self):
+        data = {
+            'full_name': self.full_name,
+            'full_name_or_username': self.full_name_or_username,
+            'short_contact': self.short_contact,
+            'full_contact': self.full_contact,
+        }
+        data.update(self.get_api_data())
+        return data
+
+
+class UserApiKeys(Base, BaseModel):
+    __tablename__ = 'user_api_keys'
+    __table_args__ = (
+        Index('uak_api_key_idx', 'api_key'),
+        Index('uak_api_key_expires_idx', 'api_key', 'expires'),
+        UniqueConstraint('api_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    # ApiKey role
+    ROLE_ALL = 'token_role_all'
+    ROLE_HTTP = 'token_role_http'
+    ROLE_VCS = 'token_role_vcs'
+    ROLE_API = 'token_role_api'
+    ROLE_FEED = 'token_role_feed'
+    ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
+
+    user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    api_key = Column("api_key", String(255), nullable=False, unique=True)
+    description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
+    expires = Column('expires', Float(53), nullable=False)
+    role = Column('role', String(255), nullable=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    user = relationship('User', lazy='joined')
+
+    @classmethod
+    def _get_role_name(cls, role):
+        return {
+            cls.ROLE_ALL: _('all'),
+            cls.ROLE_HTTP: _('http/web interface'),
+            cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
+            cls.ROLE_API: _('api calls'),
+            cls.ROLE_FEED: _('feed access'),
+        }.get(role, role)
+
+    @property
+    def expired(self):
+        if self.expires == -1:
+            return False
+        return time.time() > self.expires
+
+    @property
+    def role_humanized(self):
+        return self._get_role_name(self.role)
+
+
+class UserEmailMap(Base, BaseModel):
+    __tablename__ = 'user_email_map'
+    __table_args__ = (
+        Index('uem_email_idx', 'email'),
+        UniqueConstraint('email'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    _email = Column("email", String(255), nullable=True, unique=False, default=None)
+    user = relationship('User', lazy='joined')
+
+    @validates('_email')
+    def validate_email(self, key, email):
+        # check if this email is not main one
+        main_email = Session().query(User).filter(User.email == email).scalar()
+        if main_email is not None:
+            raise AttributeError('email %s is present is user table' % email)
+        return email
+
+    @hybrid_property
+    def email(self):
+        return self._email
+
+    @email.setter
+    def email(self, val):
+        self._email = val.lower() if val else None
+
+
+class UserIpMap(Base, BaseModel):
+    __tablename__ = 'user_ip_map'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'ip_addr'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
+    active = Column("active", Boolean(), nullable=True, unique=None, default=True)
+    description = Column("description", String(10000), nullable=True, unique=None, default=None)
+    user = relationship('User', lazy='joined')
+
+    @classmethod
+    def _get_ip_range(cls, ip_addr):
+        net = ipaddress.ip_network(ip_addr, strict=False)
+        return [str(net.network_address), str(net.broadcast_address)]
+
+    def __json__(self):
+        return {
+          'ip_addr': self.ip_addr,
+          'ip_range': self._get_ip_range(self.ip_addr),
+        }
+
+    def __unicode__(self):
+        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
+                                            self.user_id, self.ip_addr)
+
+class UserLog(Base, BaseModel):
+    __tablename__ = 'user_logs'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    username = Column("username", String(255), nullable=True, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
+    repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
+    user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
+    action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
+    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.repository_name,
+                                      self.action)
+
+    @property
+    def action_as_day(self):
+        return datetime.date(*self.action_date.timetuple()[:3])
+
+    user = relationship('User')
+    repository = relationship('Repository', cascade='')
+
+
+class UserGroup(Base, BaseModel):
+    __tablename__ = 'users_groups'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
+    user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
+    users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
+    inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
+
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
+    users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
+    user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
+    user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
+
+    user = relationship('User')
+
+    @hybrid_property
+    def group_data(self):
+        if not self._group_data:
+            return {}
+
+        try:
+            return json.loads(self._group_data)
+        except TypeError:
+            return {}
+
+    @group_data.setter
+    def group_data(self, val):
+        try:
+            self._group_data = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.users_group_id,
+                                      self.users_group_name)
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False,
+                          case_insensitive=False):
+        if case_insensitive:
+            q = cls.query().filter(func.lower(cls.users_group_name) ==
+                                   func.lower(group_name))
+
+        else:
+            q = cls.query().filter(cls.users_group_name == group_name)
+        if cache:
+            q = q.options(FromCache(
+                            "sql_cache_short",
+                            "get_group_%s" % _hash_key(group_name)))
+        return q.scalar()
+
+    @classmethod
+    def get(cls, user_group_id, cache=False):
+        user_group = cls.query()
+        if cache:
+            user_group = user_group.options(FromCache("sql_cache_short",
+                                    "get_users_group_%s" % user_group_id))
+        return user_group.get(user_group_id)
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
+        q = q.options(joinedload(UserUserGroupToPerm.user_group),
+                      joinedload(UserUserGroupToPerm.user),
+                      joinedload(UserUserGroupToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'usergroup.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
+        q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
+                      joinedload(UserGroupUserGroupToPerm.target_user_group),
+                      joinedload(UserGroupUserGroupToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.user_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def _get_default_perms(self, user_group, suffix=''):
+        from rhodecode.model.permission import PermissionModel
+        return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
+
+    def get_default_perms(self, suffix=''):
+        return self._get_default_perms(self, suffix)
+
+    def get_api_data(self, with_group_members=True, include_secrets=False):
+        """
+        :param include_secrets: See :meth:`User.get_api_data`, this parameter is
+           basically forwarded.
+
+        """
+        user_group = self
+
+        data = {
+            'users_group_id': user_group.users_group_id,
+            'group_name': user_group.users_group_name,
+            'group_description': user_group.user_group_description,
+            'active': user_group.users_group_active,
+            'owner': user_group.user.username,
+        }
+        if with_group_members:
+            users = []
+            for user in user_group.members:
+                user = user.user
+                users.append(user.get_api_data(include_secrets=include_secrets))
+            data['users'] = users
+
+        return data
+
+
+class UserGroupMember(Base, BaseModel):
+    __tablename__ = 'users_groups_members'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User', lazy='joined')
+    users_group = relationship('UserGroup')
+
+    def __init__(self, gr_id='', u_id=''):
+        self.users_group_id = gr_id
+        self.user_id = u_id
+
+
+class RepositoryField(Base, BaseModel):
+    __tablename__ = 'repositories_fields'
+    __table_args__ = (
+        UniqueConstraint('repository_id', 'field_key'),  # no-multi field
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields
+
+    repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+    field_key = Column("field_key", String(250))
+    field_label = Column("field_label", String(1024), nullable=False)
+    field_value = Column("field_value", String(10000), nullable=False)
+    field_desc = Column("field_desc", String(1024), nullable=False)
+    field_type = Column("field_type", String(255), nullable=False, unique=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    repository = relationship('Repository')
+
+    @property
+    def field_key_prefixed(self):
+        return 'ex_%s' % self.field_key
+
+    @classmethod
+    def un_prefix_key(cls, key):
+        if key.startswith(cls.PREFIX):
+            return key[len(cls.PREFIX):]
+        return key
+
+    @classmethod
+    def get_by_key_name(cls, key, repo):
+        row = cls.query()\
+                .filter(cls.repository == repo)\
+                .filter(cls.field_key == key).scalar()
+        return row
+
+
+class Repository(Base, BaseModel):
+    __tablename__ = 'repositories'
+    __table_args__ = (
+        Index('r_repo_name_idx', 'repo_name', mysql_length=255),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
+    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
+
+    STATE_CREATED = 'repo_state_created'
+    STATE_PENDING = 'repo_state_pending'
+    STATE_ERROR = 'repo_state_error'
+
+    LOCK_AUTOMATIC = 'lock_auto'
+    LOCK_API = 'lock_api'
+    LOCK_WEB = 'lock_web'
+    LOCK_PULL = 'lock_pull'
+
+    NAME_SEP = URL_SEP
+
+    repo_id = Column(
+        "repo_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    _repo_name = Column(
+        "repo_name", Text(), nullable=False, default=None)
+    _repo_name_hash = Column(
+        "repo_name_hash", String(255), nullable=False, unique=True)
+    repo_state = Column("repo_state", String(255), nullable=True)
+
+    clone_uri = Column(
+        "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
+        default=None)
+    repo_type = Column(
+        "repo_type", String(255), nullable=False, unique=False, default=None)
+    user_id = Column(
+        "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
+        unique=False, default=None)
+    private = Column(
+        "private", Boolean(), nullable=True, unique=None, default=None)
+    enable_statistics = Column(
+        "statistics", Boolean(), nullable=True, unique=None, default=True)
+    enable_downloads = Column(
+        "downloads", Boolean(), nullable=True, unique=None, default=True)
+    description = Column(
+        "description", String(10000), nullable=True, unique=None, default=None)
+    created_on = Column(
+        'created_on', DateTime(timezone=False), nullable=True, unique=None,
+        default=datetime.datetime.now)
+    updated_on = Column(
+        'updated_on', DateTime(timezone=False), nullable=True, unique=None,
+        default=datetime.datetime.now)
+    _landing_revision = Column(
+        "landing_revision", String(255), nullable=False, unique=False,
+        default=None)
+    enable_locking = Column(
+        "enable_locking", Boolean(), nullable=False, unique=None,
+        default=False)
+    _locked = Column(
+        "locked", String(255), nullable=True, unique=False, default=None)
+    _changeset_cache = Column(
+        "changeset_cache", LargeBinary(), nullable=True)  # JSON data
+
+    fork_id = Column(
+        "fork_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=True, unique=False, default=None)
+    group_id = Column(
+        "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
+        unique=False, default=None)
+
+    user = relationship('User', lazy='joined')
+    fork = relationship('Repository', remote_side=repo_id, lazy='joined')
+    group = relationship('RepoGroup', lazy='joined')
+    repo_to_perm = relationship(
+        'UserRepoToPerm', cascade='all',
+        order_by='UserRepoToPerm.repo_to_perm_id')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
+    stats = relationship('Statistics', cascade='all', uselist=False)
+
+    followers = relationship(
+        'UserFollowing',
+        primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
+        cascade='all')
+    extra_fields = relationship(
+        'RepositoryField', cascade="all, delete, delete-orphan")
+    logs = relationship('UserLog')
+    comments = relationship(
+        'ChangesetComment', cascade="all, delete, delete-orphan")
+    pull_requests_source = relationship(
+        'PullRequest',
+        primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
+        cascade="all, delete, delete-orphan")
+    pull_requests_target = relationship(
+        'PullRequest',
+        primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
+        cascade="all, delete, delete-orphan")
+    ui = relationship('RepoRhodeCodeUi', cascade="all")
+    settings = relationship('RepoRhodeCodeSetting', cascade="all")
+    integrations = relationship('Integration',
+                                cascade="all, delete, delete-orphan")
+
+    def __unicode__(self):
+        return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
+                                   safe_unicode(self.repo_name))
+
+    @hybrid_property
+    def landing_rev(self):
+        # always should return [rev_type, rev]
+        if self._landing_revision:
+            _rev_info = self._landing_revision.split(':')
+            if len(_rev_info) < 2:
+                _rev_info.insert(0, 'rev')
+            return [_rev_info[0], _rev_info[1]]
+        return [None, None]
+
+    @landing_rev.setter
+    def landing_rev(self, val):
+        if ':' not in val:
+            raise ValueError('value must be delimited with `:` and consist '
+                             'of <rev_type>:<rev>, got %s instead' % val)
+        self._landing_revision = val
+
+    @hybrid_property
+    def locked(self):
+        if self._locked:
+            user_id, timelocked, reason = self._locked.split(':')
+            lock_values = int(user_id), timelocked, reason
+        else:
+            lock_values = [None, None, None]
+        return lock_values
+
+    @locked.setter
+    def locked(self, val):
+        if val and isinstance(val, (list, tuple)):
+            self._locked = ':'.join(map(str, val))
+        else:
+            self._locked = None
+
+    @hybrid_property
+    def changeset_cache(self):
+        from rhodecode.lib.vcs.backends.base import EmptyCommit
+        dummy = EmptyCommit().__json__()
+        if not self._changeset_cache:
+            return dummy
+        try:
+            return json.loads(self._changeset_cache)
+        except TypeError:
+            return dummy
+        except Exception:
+            log.error(traceback.format_exc())
+            return dummy
+
+    @changeset_cache.setter
+    def changeset_cache(self, val):
+        try:
+            self._changeset_cache = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    @hybrid_property
+    def repo_name(self):
+        return self._repo_name
+
+    @repo_name.setter
+    def repo_name(self, value):
+        self._repo_name = value
+        self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
+
+    @classmethod
+    def normalize_repo_name(cls, repo_name):
+        """
+        Normalizes os specific repo_name to the format internally stored inside
+        database using URL_SEP
+
+        :param cls:
+        :param repo_name:
+        """
+        return cls.NAME_SEP.join(repo_name.split(os.sep))
+
+    @classmethod
+    def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
+        session = Session()
+        q = session.query(cls).filter(cls.repo_name == repo_name)
+
+        if cache:
+            if identity_cache:
+                val = cls.identity_cache(session, 'repo_name', repo_name)
+                if val:
+                    return val
+            else:
+                q = q.options(
+                    FromCache("sql_cache_short",
+                              "get_repo_by_name_%s" % _hash_key(repo_name)))
+
+        return q.scalar()
+
+    @classmethod
+    def get_by_full_path(cls, repo_full_path):
+        repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
+        repo_name = cls.normalize_repo_name(repo_name)
+        return cls.get_by_repo_name(repo_name.strip(URL_SEP))
+
+    @classmethod
+    def get_repo_forks(cls, repo_id):
+        return cls.query().filter(Repository.fork_id == repo_id)
+
+    @classmethod
+    def base_path(cls):
+        """
+        Returns base path when all repos are stored
+
+        :param cls:
+        """
+        q = Session().query(RhodeCodeUi)\
+            .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @classmethod
+    def is_valid(cls, repo_name):
+        """
+        returns True if given repo name is a valid filesystem repository
+
+        :param cls:
+        :param repo_name:
+        """
+        from rhodecode.lib.utils import is_valid_repo
+
+        return is_valid_repo(repo_name, cls.base_path())
+
+    @classmethod
+    def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
+                      case_insensitive=True):
+        q = Repository.query()
+
+        if not isinstance(user_id, Optional):
+            q = q.filter(Repository.user_id == user_id)
+
+        if not isinstance(group_id, Optional):
+            q = q.filter(Repository.group_id == group_id)
+
+        if case_insensitive:
+            q = q.order_by(func.lower(Repository.repo_name))
+        else:
+            q = q.order_by(Repository.repo_name)
+        return q.all()
+
+    @property
+    def forks(self):
+        """
+        Return forks of this repo
+        """
+        return Repository.get_repo_forks(self.repo_id)
+
+    @property
+    def parent(self):
+        """
+        Returns fork parent
+        """
+        return self.fork
+
+    @property
+    def just_name(self):
+        return self.repo_name.split(self.NAME_SEP)[-1]
+
+    @property
+    def groups_with_parents(self):
+        groups = []
+        if self.group is None:
+            return groups
+
+        cur_gr = self.group
+        groups.insert(0, cur_gr)
+        while 1:
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            groups.insert(0, gr)
+
+        return groups
+
+    @property
+    def groups_and_repo(self):
+        return self.groups_with_parents, self
+
+    @LazyProperty
+    def repo_path(self):
+        """
+        Returns base full path for that repository means where it actually
+        exists on a filesystem
+        """
+        q = Session().query(RhodeCodeUi).filter(
+            RhodeCodeUi.ui_key == self.NAME_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @property
+    def repo_full_path(self):
+        p = [self.repo_path]
+        # we need to split the name by / since this is how we store the
+        # names in the database, but that eventually needs to be converted
+        # into a valid system path
+        p += self.repo_name.split(self.NAME_SEP)
+        return os.path.join(*map(safe_unicode, p))
+
+    @property
+    def cache_keys(self):
+        """
+        Returns associated cache keys for that repo
+        """
+        return CacheKey.query()\
+            .filter(CacheKey.cache_args == self.repo_name)\
+            .order_by(CacheKey.cache_key)\
+            .all()
+
+    def get_new_name(self, repo_name):
+        """
+        returns new full repository name based on assigned group and new new
+
+        :param group_name:
+        """
+        path_prefix = self.group.full_path_splitted if self.group else []
+        return self.NAME_SEP.join(path_prefix + [repo_name])
+
+    @property
+    def _config(self):
+        """
+        Returns db based config object.
+        """
+        from rhodecode.lib.utils import make_db_config
+        return make_db_config(clear_session=False, repo=self)
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
+        q = q.options(joinedload(UserRepoToPerm.repository),
+                      joinedload(UserRepoToPerm.user),
+                      joinedload(UserRepoToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'repository.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupRepoToPerm.query().filter(
+            UserGroupRepoToPerm.repository == self)
+        q = q.options(joinedload(UserGroupRepoToPerm.repository),
+                      joinedload(UserGroupRepoToPerm.users_group),
+                      joinedload(UserGroupRepoToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.users_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def get_api_data(self, include_secrets=False):
+        """
+        Common function for generating repo api data
+
+        :param include_secrets: See :meth:`User.get_api_data`.
+
+        """
+        # TODO: mikhail: Here there is an anti-pattern, we probably need to
+        # move this methods on models level.
+        from rhodecode.model.settings import SettingsModel
+
+        repo = self
+        _user_id, _time, _reason = self.locked
+
+        data = {
+            'repo_id': repo.repo_id,
+            'repo_name': repo.repo_name,
+            'repo_type': repo.repo_type,
+            'clone_uri': repo.clone_uri or '',
+            'url': url('summary_home', repo_name=self.repo_name, qualified=True),
+            'private': repo.private,
+            'created_on': repo.created_on,
+            'description': repo.description,
+            'landing_rev': repo.landing_rev,
+            'owner': repo.user.username,
+            'fork_of': repo.fork.repo_name if repo.fork else None,
+            'enable_statistics': repo.enable_statistics,
+            'enable_locking': repo.enable_locking,
+            'enable_downloads': repo.enable_downloads,
+            'last_changeset': repo.changeset_cache,
+            'locked_by': User.get(_user_id).get_api_data(
+                include_secrets=include_secrets) if _user_id else None,
+            'locked_date': time_to_datetime(_time) if _time else None,
+            'lock_reason': _reason if _reason else None,
+        }
+
+        # TODO: mikhail: should be per-repo settings here
+        rc_config = SettingsModel().get_all_settings()
+        repository_fields = str2bool(
+            rc_config.get('rhodecode_repository_fields'))
+        if repository_fields:
+            for f in self.extra_fields:
+                data[f.field_key_prefixed] = f.field_value
+
+        return data
+
+    @classmethod
+    def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
+        if not lock_time:
+            lock_time = time.time()
+        if not lock_reason:
+            lock_reason = cls.LOCK_AUTOMATIC
+        repo.locked = [user_id, lock_time, lock_reason]
+        Session().add(repo)
+        Session().commit()
+
+    @classmethod
+    def unlock(cls, repo):
+        repo.locked = None
+        Session().add(repo)
+        Session().commit()
+
+    @classmethod
+    def getlock(cls, repo):
+        return repo.locked
+
+    def is_user_lock(self, user_id):
+        if self.lock[0]:
+            lock_user_id = safe_int(self.lock[0])
+            user_id = safe_int(user_id)
+            # both are ints, and they are equal
+            return all([lock_user_id, user_id]) and lock_user_id == user_id
+
+        return False
+
+    def get_locking_state(self, action, user_id, only_when_enabled=True):
+        """
+        Checks locking on this repository, if locking is enabled and lock is
+        present returns a tuple of make_lock, locked, locked_by.
+        make_lock can have 3 states None (do nothing) True, make lock
+        False release lock, This value is later propagated to hooks, which
+        do the locking. Think about this as signals passed to hooks what to do.
+
+        """
+        # TODO: johbo: This is part of the business logic and should be moved
+        # into the RepositoryModel.
+
+        if action not in ('push', 'pull'):
+            raise ValueError("Invalid action value: %s" % repr(action))
+
+        # defines if locked error should be thrown to user
+        currently_locked = False
+        # defines if new lock should be made, tri-state
+        make_lock = None
+        repo = self
+        user = User.get(user_id)
+
+        lock_info = repo.locked
+
+        if repo and (repo.enable_locking or not only_when_enabled):
+            if action == 'push':
+                # check if it's already locked !, if it is compare users
+                locked_by_user_id = lock_info[0]
+                if user.user_id == locked_by_user_id:
+                    log.debug(
+                        'Got `push` action from user %s, now unlocking', user)
+                    # unlock if we have push from user who locked
+                    make_lock = False
+                else:
+                    # we're not the same user who locked, ban with
+                    # code defined in settings (default is 423 HTTP Locked) !
+                    log.debug('Repo %s is currently locked by %s', repo, user)
+                    currently_locked = True
+            elif action == 'pull':
+                # [0] user [1] date
+                if lock_info[0] and lock_info[1]:
+                    log.debug('Repo %s is currently locked by %s', repo, user)
+                    currently_locked = True
+                else:
+                    log.debug('Setting lock on repo %s by %s', repo, user)
+                    make_lock = True
+
+        else:
+            log.debug('Repository %s do not have locking enabled', repo)
+
+        log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
+                  make_lock, currently_locked, lock_info)
+
+        from rhodecode.lib.auth import HasRepoPermissionAny
+        perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
+        if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
+            # if we don't have at least write permission we cannot make a lock
+            log.debug('lock state reset back to FALSE due to lack '
+                      'of at least read permission')
+            make_lock = False
+
+        return make_lock, currently_locked, lock_info
+
+    @property
+    def last_db_change(self):
+        return self.updated_on
+
+    @property
+    def clone_uri_hidden(self):
+        clone_uri = self.clone_uri
+        if clone_uri:
+            import urlobject
+            url_obj = urlobject.URLObject(clone_uri)
+            if url_obj.password:
+                clone_uri = url_obj.with_password('*****')
+        return clone_uri
+
+    def clone_url(self, **override):
+        qualified_home_url = url('home', qualified=True)
+
+        uri_tmpl = None
+        if 'with_id' in override:
+            uri_tmpl = self.DEFAULT_CLONE_URI_ID
+            del override['with_id']
+
+        if 'uri_tmpl' in override:
+            uri_tmpl = override['uri_tmpl']
+            del override['uri_tmpl']
+
+        # we didn't override our tmpl from **overrides
+        if not uri_tmpl:
+            uri_tmpl = self.DEFAULT_CLONE_URI
+            try:
+                from pylons import tmpl_context as c
+                uri_tmpl = c.clone_uri_tmpl
+            except Exception:
+                # in any case if we call this outside of request context,
+                # ie, not having tmpl_context set up
+                pass
+
+        return get_clone_url(uri_tmpl=uri_tmpl,
+                             qualifed_home_url=qualified_home_url,
+                             repo_name=self.repo_name,
+                             repo_id=self.repo_id, **override)
+
+    def set_state(self, state):
+        self.repo_state = state
+        Session().add(self)
+    #==========================================================================
+    # SCM PROPERTIES
+    #==========================================================================
+
+    def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
+        return get_commit_safe(
+            self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
+
+    def get_changeset(self, rev=None, pre_load=None):
+        warnings.warn("Use get_commit", DeprecationWarning)
+        commit_id = None
+        commit_idx = None
+        if isinstance(rev, basestring):
+            commit_id = rev
+        else:
+            commit_idx = rev
+        return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
+                               pre_load=pre_load)
+
+    def get_landing_commit(self):
+        """
+        Returns landing commit, or if that doesn't exist returns the tip
+        """
+        _rev_type, _rev = self.landing_rev
+        commit = self.get_commit(_rev)
+        if isinstance(commit, EmptyCommit):
+            return self.get_commit()
+        return commit
+
+    def update_commit_cache(self, cs_cache=None, config=None):
+        """
+        Update cache of last changeset for repository, keys should be::
+
+            short_id
+            raw_id
+            revision
+            parents
+            message
+            date
+            author
+
+        :param cs_cache:
+        """
+        from rhodecode.lib.vcs.backends.base import BaseChangeset
+        if cs_cache is None:
+            # use no-cache version here
+            scm_repo = self.scm_instance(cache=False, config=config)
+            if scm_repo:
+                cs_cache = scm_repo.get_commit(
+                    pre_load=["author", "date", "message", "parents"])
+            else:
+                cs_cache = EmptyCommit()
+
+        if isinstance(cs_cache, BaseChangeset):
+            cs_cache = cs_cache.__json__()
+
+        def is_outdated(new_cs_cache):
+            if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
+                new_cs_cache['revision'] != self.changeset_cache['revision']):
+                return True
+            return False
+
+        # check if we have maybe already latest cached revision
+        if is_outdated(cs_cache) or not self.changeset_cache:
+            _default = datetime.datetime.fromtimestamp(0)
+            last_change = cs_cache.get('date') or _default
+            log.debug('updated repo %s with new cs cache %s',
+                      self.repo_name, cs_cache)
+            self.updated_on = last_change
+            self.changeset_cache = cs_cache
+            Session().add(self)
+            Session().commit()
+        else:
+            log.debug('Skipping update_commit_cache for repo:`%s` '
+                      'commit already with latest changes', self.repo_name)
+
+    @property
+    def tip(self):
+        return self.get_commit('tip')
+
+    @property
+    def author(self):
+        return self.tip.author
+
+    @property
+    def last_change(self):
+        return self.scm_instance().last_change
+
+    def get_comments(self, revisions=None):
+        """
+        Returns comments for this repository grouped by revisions
+
+        :param revisions: filter query by revisions only
+        """
+        cmts = ChangesetComment.query()\
+            .filter(ChangesetComment.repo == self)
+        if revisions:
+            cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
+        grouped = collections.defaultdict(list)
+        for cmt in cmts.all():
+            grouped[cmt.revision].append(cmt)
+        return grouped
+
+    def statuses(self, revisions=None):
+        """
+        Returns statuses for this repository
+
+        :param revisions: list of revisions to get statuses for
+        """
+        statuses = ChangesetStatus.query()\
+            .filter(ChangesetStatus.repo == self)\
+            .filter(ChangesetStatus.version == 0)
+
+        if revisions:
+            # Try doing the filtering in chunks to avoid hitting limits
+            size = 500
+            status_results = []
+            for chunk in xrange(0, len(revisions), size):
+                status_results += statuses.filter(
+                    ChangesetStatus.revision.in_(
+                        revisions[chunk: chunk+size])
+                ).all()
+        else:
+            status_results = statuses.all()
+
+        grouped = {}
+
+        # maybe we have open new pullrequest without a status?
+        stat = ChangesetStatus.STATUS_UNDER_REVIEW
+        status_lbl = ChangesetStatus.get_status_lbl(stat)
+        for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
+            for rev in pr.revisions:
+                pr_id = pr.pull_request_id
+                pr_repo = pr.target_repo.repo_name
+                grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
+
+        for stat in status_results:
+            pr_id = pr_repo = None
+            if stat.pull_request:
+                pr_id = stat.pull_request.pull_request_id
+                pr_repo = stat.pull_request.target_repo.repo_name
+            grouped[stat.revision] = [str(stat.status), stat.status_lbl,
+                                      pr_id, pr_repo]
+        return grouped
+
+    # ==========================================================================
+    # SCM CACHE INSTANCE
+    # ==========================================================================
+
+    def scm_instance(self, **kwargs):
+        import rhodecode
+
+        # Passing a config will not hit the cache currently only used
+        # for repo2dbmapper
+        config = kwargs.pop('config', None)
+        cache = kwargs.pop('cache', None)
+        full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
+        # if cache is NOT defined use default global, else we have a full
+        # control over cache behaviour
+        if cache is None and full_cache and not config:
+            return self._get_instance_cached()
+        return self._get_instance(cache=bool(cache), config=config)
+
+    def _get_instance_cached(self):
+        @cache_region('long_term')
+        def _get_repo(cache_key):
+            return self._get_instance()
+
+        invalidator_context = CacheKey.repo_context_cache(
+            _get_repo, self.repo_name, None, thread_scoped=True)
+
+        with invalidator_context as context:
+            context.invalidate()
+            repo = context.compute()
+
+        return repo
+
+    def _get_instance(self, cache=True, config=None):
+        config = config or self._config
+        custom_wire = {
+            'cache': cache  # controls the vcs.remote cache
+        }
+
+        repo = get_vcs_instance(
+            repo_path=safe_str(self.repo_full_path),
+            config=config,
+            with_wire=custom_wire,
+            create=False)
+
+        return repo
+
+    def __json__(self):
+        return {'landing_rev': self.landing_rev}
+
+    def get_dict(self):
+
+        # Since we transformed `repo_name` to a hybrid property, we need to
+        # keep compatibility with the code which uses `repo_name` field.
+
+        result = super(Repository, self).get_dict()
+        result['repo_name'] = result.pop('_repo_name', None)
+        return result
+
+
+class RepoGroup(Base, BaseModel):
+    __tablename__ = 'groups'
+    __table_args__ = (
+        UniqueConstraint('group_name', 'group_parent_id'),
+        CheckConstraint('group_id != group_parent_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    __mapper_args__ = {'order_by': 'group_name'}
+
+    CHOICES_SEPARATOR = '/'  # used to generate select2 choices for nested groups
+
+    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
+    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
+    group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
+    enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
+    parent_group = relationship('RepoGroup', remote_side=group_id)
+    user = relationship('User')
+    integrations = relationship('Integration',
+                                cascade="all, delete, delete-orphan")
+
+    def __init__(self, group_name='', parent_group=None):
+        self.group_name = group_name
+        self.parent_group = parent_group
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
+                                      self.group_name)
+
+    @classmethod
+    def _generate_choice(cls, repo_group):
+        from webhelpers.html import literal as _literal
+        _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
+        return repo_group.group_id, _name(repo_group.full_path_splitted)
+
+    @classmethod
+    def groups_choices(cls, groups=None, show_empty_group=True):
+        if not groups:
+            groups = cls.query().all()
+
+        repo_groups = []
+        if show_empty_group:
+            repo_groups = [('-1', u'-- %s --' % _('No parent'))]
+
+        repo_groups.extend([cls._generate_choice(x) for x in groups])
+
+        repo_groups = sorted(
+            repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
+        return repo_groups
+
+    @classmethod
+    def url_sep(cls):
+        return URL_SEP
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
+        if case_insensitive:
+            gr = cls.query().filter(func.lower(cls.group_name)
+                                    == func.lower(group_name))
+        else:
+            gr = cls.query().filter(cls.group_name == group_name)
+        if cache:
+            gr = gr.options(FromCache(
+                            "sql_cache_short",
+                            "get_group_%s" % _hash_key(group_name)))
+        return gr.scalar()
+
+    @classmethod
+    def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
+                            case_insensitive=True):
+        q = RepoGroup.query()
+
+        if not isinstance(user_id, Optional):
+            q = q.filter(RepoGroup.user_id == user_id)
+
+        if not isinstance(group_id, Optional):
+            q = q.filter(RepoGroup.group_parent_id == group_id)
+
+        if case_insensitive:
+            q = q.order_by(func.lower(RepoGroup.group_name))
+        else:
+            q = q.order_by(RepoGroup.group_name)
+        return q.all()
+
+    @property
+    def parents(self):
+        parents_recursion_limit = 10
+        groups = []
+        if self.parent_group is None:
+            return groups
+        cur_gr = self.parent_group
+        groups.insert(0, cur_gr)
+        cnt = 0
+        while 1:
+            cnt += 1
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            if cnt == parents_recursion_limit:
+                # this will prevent accidental infinit loops
+                log.error(('more than %s parents found for group %s, stopping '
+                           'recursive parent fetching' % (parents_recursion_limit, self)))
+                break
+
+            groups.insert(0, gr)
+        return groups
+
+    @property
+    def children(self):
+        return RepoGroup.query().filter(RepoGroup.parent_group == self)
+
+    @property
+    def name(self):
+        return self.group_name.split(RepoGroup.url_sep())[-1]
+
+    @property
+    def full_path(self):
+        return self.group_name
+
+    @property
+    def full_path_splitted(self):
+        return self.group_name.split(RepoGroup.url_sep())
+
+    @property
+    def repositories(self):
+        return Repository.query()\
+                .filter(Repository.group == self)\
+                .order_by(Repository.repo_name)
+
+    @property
+    def repositories_recursive_count(self):
+        cnt = self.repositories.count()
+
+        def children_count(group):
+            cnt = 0
+            for child in group.children:
+                cnt += child.repositories.count()
+                cnt += children_count(child)
+            return cnt
+
+        return cnt + children_count(self)
+
+    def _recursive_objects(self, include_repos=True):
+        all_ = []
+
+        def _get_members(root_gr):
+            if include_repos:
+                for r in root_gr.repositories:
+                    all_.append(r)
+            childs = root_gr.children.all()
+            if childs:
+                for gr in childs:
+                    all_.append(gr)
+                    _get_members(gr)
+
+        _get_members(self)
+        return [self] + all_
+
+    def recursive_groups_and_repos(self):
+        """
+        Recursive return all groups, with repositories in those groups
+        """
+        return self._recursive_objects()
+
+    def recursive_groups(self):
+        """
+        Returns all children groups for this group including children of children
+        """
+        return self._recursive_objects(include_repos=False)
+
+    def get_new_name(self, group_name):
+        """
+        returns new full group name based on parent and new name
+
+        :param group_name:
+        """
+        path_prefix = (self.parent_group.full_path_splitted if
+                       self.parent_group else [])
+        return RepoGroup.url_sep().join(path_prefix + [group_name])
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
+        q = q.options(joinedload(UserRepoGroupToPerm.group),
+                      joinedload(UserRepoGroupToPerm.user),
+                      joinedload(UserRepoGroupToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'group.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
+        q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
+                      joinedload(UserGroupRepoGroupToPerm.users_group),
+                      joinedload(UserGroupRepoGroupToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.users_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def get_api_data(self):
+        """
+        Common function for generating api data
+
+        """
+        group = self
+        data = {
+            'group_id': group.group_id,
+            'group_name': group.group_name,
+            'group_description': group.group_description,
+            'parent_group': group.parent_group.group_name if group.parent_group else None,
+            'repositories': [x.repo_name for x in group.repositories],
+            'owner': group.user.username,
+        }
+        return data
+
+
+class Permission(Base, BaseModel):
+    __tablename__ = 'permissions'
+    __table_args__ = (
+        Index('p_perm_name_idx', 'permission_name'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    PERMS = [
+        ('hg.admin', _('RhodeCode Super Administrator')),
+
+        ('repository.none', _('Repository no access')),
+        ('repository.read', _('Repository read access')),
+        ('repository.write', _('Repository write access')),
+        ('repository.admin', _('Repository admin access')),
+
+        ('group.none', _('Repository group no access')),
+        ('group.read', _('Repository group read access')),
+        ('group.write', _('Repository group write access')),
+        ('group.admin', _('Repository group admin access')),
+
+        ('usergroup.none', _('User group no access')),
+        ('usergroup.read', _('User group read access')),
+        ('usergroup.write', _('User group write access')),
+        ('usergroup.admin', _('User group admin access')),
+
+        ('hg.repogroup.create.false', _('Repository Group creation disabled')),
+        ('hg.repogroup.create.true', _('Repository Group creation enabled')),
+
+        ('hg.usergroup.create.false', _('User Group creation disabled')),
+        ('hg.usergroup.create.true', _('User Group creation enabled')),
+
+        ('hg.create.none', _('Repository creation disabled')),
+        ('hg.create.repository', _('Repository creation enabled')),
+        ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
+        ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
+
+        ('hg.fork.none', _('Repository forking disabled')),
+        ('hg.fork.repository', _('Repository forking enabled')),
+
+        ('hg.register.none', _('Registration disabled')),
+        ('hg.register.manual_activate', _('User Registration with manual account activation')),
+        ('hg.register.auto_activate', _('User Registration with automatic account activation')),
+
+        ('hg.extern_activate.manual', _('Manual activation of external account')),
+        ('hg.extern_activate.auto', _('Automatic activation of external account')),
+
+        ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
+        ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
+    ]
+
+    # definition of system default permissions for DEFAULT user
+    DEFAULT_USER_PERMISSIONS = [
+        'repository.read',
+        'group.read',
+        'usergroup.read',
+        'hg.create.repository',
+        'hg.repogroup.create.false',
+        'hg.usergroup.create.false',
+        'hg.create.write_on_repogroup.true',
+        'hg.fork.repository',
+        'hg.register.manual_activate',
+        'hg.extern_activate.auto',
+        'hg.inherit_default_perms.true',
+    ]
+
+    # defines which permissions are more important higher the more important
+    # Weight defines which permissions are more important.
+    # The higher number the more important.
+    PERM_WEIGHTS = {
+        'repository.none': 0,
+        'repository.read': 1,
+        'repository.write': 3,
+        'repository.admin': 4,
+
+        'group.none': 0,
+        'group.read': 1,
+        'group.write': 3,
+        'group.admin': 4,
+
+        'usergroup.none': 0,
+        'usergroup.read': 1,
+        'usergroup.write': 3,
+        'usergroup.admin': 4,
+
+        'hg.repogroup.create.false': 0,
+        'hg.repogroup.create.true': 1,
+
+        'hg.usergroup.create.false': 0,
+        'hg.usergroup.create.true': 1,
+
+        'hg.fork.none': 0,
+        'hg.fork.repository': 1,
+        'hg.create.none': 0,
+        'hg.create.repository': 1
+    }
+
+    permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
+    permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
+
+    def __unicode__(self):
+        return u"<%s('%s:%s')>" % (
+            self.__class__.__name__, self.permission_id, self.permission_name
+        )
+
+    @classmethod
+    def get_by_key(cls, key):
+        return cls.query().filter(cls.permission_name == key).scalar()
+
+    @classmethod
+    def get_default_repo_perms(cls, user_id, repo_id=None):
+        q = Session().query(UserRepoToPerm, Repository, Permission)\
+            .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
+            .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
+            .filter(UserRepoToPerm.user_id == user_id)
+        if repo_id:
+            q = q.filter(UserRepoToPerm.repository_id == repo_id)
+        return q.all()
+
+    @classmethod
+    def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
+        q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
+            .join(
+                Permission,
+                UserGroupRepoToPerm.permission_id == Permission.permission_id)\
+            .join(
+                Repository,
+                UserGroupRepoToPerm.repository_id == Repository.repo_id)\
+            .join(
+                UserGroup,
+                UserGroupRepoToPerm.users_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupRepoToPerm.users_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if repo_id:
+            q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
+        return q.all()
+
+    @classmethod
+    def get_default_group_perms(cls, user_id, repo_group_id=None):
+        q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
+            .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
+            .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
+            .filter(UserRepoGroupToPerm.user_id == user_id)
+        if repo_group_id:
+            q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_group_perms_from_user_group(
+            cls, user_id, repo_group_id=None):
+        q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
+            .join(
+                Permission,
+                UserGroupRepoGroupToPerm.permission_id ==
+                Permission.permission_id)\
+            .join(
+                RepoGroup,
+                UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
+            .join(
+                UserGroup,
+                UserGroupRepoGroupToPerm.users_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupRepoGroupToPerm.users_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if repo_group_id:
+            q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_user_group_perms(cls, user_id, user_group_id=None):
+        q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
+            .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
+            .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
+            .filter(UserUserGroupToPerm.user_id == user_id)
+        if user_group_id:
+            q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_user_group_perms_from_user_group(
+            cls, user_id, user_group_id=None):
+        TargetUserGroup = aliased(UserGroup, name='target_user_group')
+        q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
+            .join(
+                Permission,
+                UserGroupUserGroupToPerm.permission_id ==
+                Permission.permission_id)\
+            .join(
+                TargetUserGroup,
+                UserGroupUserGroupToPerm.target_user_group_id ==
+                TargetUserGroup.users_group_id)\
+            .join(
+                UserGroup,
+                UserGroupUserGroupToPerm.user_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupUserGroupToPerm.user_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if user_group_id:
+            q = q.filter(
+                UserGroupUserGroupToPerm.user_group_id == user_group_id)
+
+        return q.all()
+
+
+class UserRepoToPerm(Base, BaseModel):
+    __tablename__ = 'repo_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'repository_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    repository = relationship('Repository')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, repository, permission):
+        n = cls()
+        n.user = user
+        n.repository = repository
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.repository)
+
+
+class UserUserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_user_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    user_group = relationship('UserGroup')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, user_group, permission):
+        n = cls()
+        n.user = user
+        n.user_group = user_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.user_group)
+
+
+class UserToPerm(Base, BaseModel):
+    __tablename__ = 'user_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    permission = relationship('Permission', lazy='joined')
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.permission)
+
+
+class UserGroupRepoToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_repo_to_perm'
+    __table_args__ = (
+        UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+    repository = relationship('Repository')
+
+    @classmethod
+    def create(cls, users_group, repository, permission):
+        n = cls()
+        n.users_group = users_group
+        n.repository = repository
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
+
+
+class UserGroupUserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_group_user_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
+        CheckConstraint('target_user_group_id != user_group_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+
+    target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
+    user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, target_user_group, user_group, permission):
+        n = cls()
+        n.target_user_group = target_user_group
+        n.user_group = user_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
+
+
+class UserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('users_group_id', 'permission_id',),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+
+
+class UserRepoGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_repo_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    group = relationship('RepoGroup')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, repository_group, permission):
+        n = cls()
+        n.user = user
+        n.group = repository_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+
+class UserGroupRepoGroupToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_repo_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('users_group_id', 'group_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+    group = relationship('RepoGroup')
+
+    @classmethod
+    def create(cls, user_group, repository_group, permission):
+        n = cls()
+        n.users_group = user_group
+        n.group = repository_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
+
+
+class Statistics(Base, BaseModel):
+    __tablename__ = 'statistics'
+    __table_args__ = (
+         UniqueConstraint('repository_id'),
+         {'extend_existing': True, 'mysql_engine': 'InnoDB',
+          'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
+    stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
+    commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
+    commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
+    languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
+
+    repository = relationship('Repository', single_parent=True)
+
+
+class UserFollowing(Base, BaseModel):
+    __tablename__ = 'user_followings'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'follows_repository_id'),
+        UniqueConstraint('user_id', 'follows_user_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
+    follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
+
+    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
+
+    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
+    follows_repository = relationship('Repository', order_by='Repository.repo_name')
+
+    @classmethod
+    def get_repo_followers(cls, repo_id):
+        return cls.query().filter(cls.follows_repo_id == repo_id)
+
+
+class CacheKey(Base, BaseModel):
+    __tablename__ = 'cache_invalidation'
+    __table_args__ = (
+        UniqueConstraint('cache_key'),
+        Index('key_idx', 'cache_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    CACHE_TYPE_ATOM = 'ATOM'
+    CACHE_TYPE_RSS = 'RSS'
+    CACHE_TYPE_README = 'README'
+
+    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
+    cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
+    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
+
+    def __init__(self, cache_key, cache_args=''):
+        self.cache_key = cache_key
+        self.cache_args = cache_args
+        self.cache_active = False
+
+    def __unicode__(self):
+        return u"<%s('%s:%s[%s]')>" % (
+            self.__class__.__name__,
+            self.cache_id, self.cache_key, self.cache_active)
+
+    def _cache_key_partition(self):
+        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
+        return prefix, repo_name, suffix
+
+    def get_prefix(self):
+        """
+        Try to extract prefix from existing cache key. The key could consist
+        of prefix, repo_name, suffix
+        """
+        # this returns prefix, repo_name, suffix
+        return self._cache_key_partition()[0]
+
+    def get_suffix(self):
+        """
+        get suffix that might have been used in _get_cache_key to
+        generate self.cache_key. Only used for informational purposes
+        in repo_edit.html.
+        """
+        # prefix, repo_name, suffix
+        return self._cache_key_partition()[2]
+
+    @classmethod
+    def delete_all_cache(cls):
+        """
+        Delete all cache keys from database.
+        Should only be run when all instances are down and all entries
+        thus stale.
+        """
+        cls.query().delete()
+        Session().commit()
+
+    @classmethod
+    def get_cache_key(cls, repo_name, cache_type):
+        """
+
+        Generate a cache key for this process of RhodeCode instance.
+        Prefix most likely will be process id or maybe explicitly set
+        instance_id from .ini file.
+        """
+        import rhodecode
+        prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
+
+        repo_as_unicode = safe_unicode(repo_name)
+        key = u'{}_{}'.format(repo_as_unicode, cache_type) \
+            if cache_type else repo_as_unicode
+
+        return u'{}{}'.format(prefix, key)
+
+    @classmethod
+    def set_invalidate(cls, repo_name, delete=False):
+        """
+        Mark all caches of a repo as invalid in the database.
+        """
+
+        try:
+            qry = Session().query(cls).filter(cls.cache_args == repo_name)
+            if delete:
+                log.debug('cache objects deleted for repo %s',
+                          safe_str(repo_name))
+                qry.delete()
+            else:
+                log.debug('cache objects marked as invalid for repo %s',
+                          safe_str(repo_name))
+                qry.update({"cache_active": False})
+
+            Session().commit()
+        except Exception:
+            log.exception(
+                'Cache key invalidation failed for repository %s',
+                safe_str(repo_name))
+            Session().rollback()
+
+    @classmethod
+    def get_active_cache(cls, cache_key):
+        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
+        if inv_obj:
+            return inv_obj
+        return None
+
+    @classmethod
+    def repo_context_cache(cls, compute_func, repo_name, cache_type,
+                           thread_scoped=False):
+        """
+        @cache_region('long_term')
+        def _heavy_calculation(cache_key):
+            return 'result'
+
+        cache_context = CacheKey.repo_context_cache(
+            _heavy_calculation, repo_name, cache_type)
+
+        with cache_context as context:
+            context.invalidate()
+            computed = context.compute()
+
+        assert computed == 'result'
+        """
+        from rhodecode.lib import caches
+        return caches.InvalidationContext(
+            compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
+
+
+class ChangesetComment(Base, BaseModel):
+    __tablename__ = 'changeset_comments'
+    __table_args__ = (
+        Index('cc_revision_idx', 'revision'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    COMMENT_OUTDATED = u'comment_outdated'
+
+    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
+    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
+    revision = Column('revision', String(40), nullable=True)
+    pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
+    pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
+    line_no = Column('line_no', Unicode(10), nullable=True)
+    hl_lines = Column('hl_lines', Unicode(512), nullable=True)
+    f_path = Column('f_path', Unicode(1000), nullable=True)
+    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
+    text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    renderer = Column('renderer', Unicode(64), nullable=True)
+    display_state = Column('display_state',  Unicode(128), nullable=True)
+
+    author = relationship('User', lazy='joined')
+    repo = relationship('Repository')
+    status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
+    pull_request = relationship('PullRequest', lazy='joined')
+    pull_request_version = relationship('PullRequestVersion')
+
+    @classmethod
+    def get_users(cls, revision=None, pull_request_id=None):
+        """
+        Returns user associated with this ChangesetComment. ie those
+        who actually commented
+
+        :param cls:
+        :param revision:
+        """
+        q = Session().query(User)\
+                .join(ChangesetComment.author)
+        if revision:
+            q = q.filter(cls.revision == revision)
+        elif pull_request_id:
+            q = q.filter(cls.pull_request_id == pull_request_id)
+        return q.all()
+
+    def render(self, mentions=False):
+        from rhodecode.lib import helpers as h
+        return h.render(self.text, renderer=self.renderer, mentions=mentions)
+
+    def __repr__(self):
+        if self.comment_id:
+            return '<DB:ChangesetComment #%s>' % self.comment_id
+        else:
+            return '<DB:ChangesetComment at %#x>' % id(self)
+
+
+class ChangesetStatus(Base, BaseModel):
+    __tablename__ = 'changeset_statuses'
+    __table_args__ = (
+        Index('cs_revision_idx', 'revision'),
+        Index('cs_version_idx', 'version'),
+        UniqueConstraint('repo_id', 'revision', 'version'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
+    STATUS_APPROVED = 'approved'
+    STATUS_REJECTED = 'rejected'
+    STATUS_UNDER_REVIEW = 'under_review'
+
+    STATUSES = [
+        (STATUS_NOT_REVIEWED, _("Not Reviewed")),  # (no icon) and default
+        (STATUS_APPROVED, _("Approved")),
+        (STATUS_REJECTED, _("Rejected")),
+        (STATUS_UNDER_REVIEW, _("Under Review")),
+    ]
+
+    changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
+    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
+    revision = Column('revision', String(40), nullable=False)
+    status = Column('status', String(128), nullable=False, default=DEFAULT)
+    changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
+    modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
+    version = Column('version', Integer(), nullable=False, default=0)
+    pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
+
+    author = relationship('User', lazy='joined')
+    repo = relationship('Repository')
+    comment = relationship('ChangesetComment', lazy='joined')
+    pull_request = relationship('PullRequest', lazy='joined')
+
+    def __unicode__(self):
+        return u"<%s('%s[%s]:%s')>" % (
+            self.__class__.__name__,
+            self.status, self.version, self.author
+        )
+
+    @classmethod
+    def get_status_lbl(cls, value):
+        return dict(cls.STATUSES).get(value)
+
+    @property
+    def status_lbl(self):
+        return ChangesetStatus.get_status_lbl(self.status)
+
+
+class _PullRequestBase(BaseModel):
+    """
+    Common attributes of pull request and version entries.
+    """
+
+    # .status values
+    STATUS_NEW = u'new'
+    STATUS_OPEN = u'open'
+    STATUS_CLOSED = u'closed'
+
+    title = Column('title', Unicode(255), nullable=True)
+    description = Column(
+        'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
+        nullable=True)
+    # new/open/closed status of pull request (not approve/reject/etc)
+    status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
+    created_on = Column(
+        'created_on', DateTime(timezone=False), nullable=False,
+        default=datetime.datetime.now)
+    updated_on = Column(
+        'updated_on', DateTime(timezone=False), nullable=False,
+        default=datetime.datetime.now)
+
+    @declared_attr
+    def user_id(cls):
+        return Column(
+            "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
+            unique=None)
+
+    # 500 revisions max
+    _revisions = Column(
+        'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
+
+    @declared_attr
+    def source_repo_id(cls):
+        # TODO: dan: rename column to source_repo_id
+        return Column(
+            'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
+            nullable=False)
+
+    source_ref = Column('org_ref', Unicode(255), nullable=False)
+
+    @declared_attr
+    def target_repo_id(cls):
+        # TODO: dan: rename column to target_repo_id
+        return Column(
+            'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
+            nullable=False)
+
+    target_ref = Column('other_ref', Unicode(255), nullable=False)
+
+    # TODO: dan: rename column to last_merge_source_rev
+    _last_merge_source_rev = Column(
+        'last_merge_org_rev', String(40), nullable=True)
+    # TODO: dan: rename column to last_merge_target_rev
+    _last_merge_target_rev = Column(
+        'last_merge_other_rev', String(40), nullable=True)
+    _last_merge_status = Column('merge_status', Integer(), nullable=True)
+    merge_rev = Column('merge_rev', String(40), nullable=True)
+
+    @hybrid_property
+    def revisions(self):
+        return self._revisions.split(':') if self._revisions else []
+
+    @revisions.setter
+    def revisions(self, val):
+        self._revisions = ':'.join(val)
+
+    @declared_attr
+    def author(cls):
+        return relationship('User', lazy='joined')
+
+    @declared_attr
+    def source_repo(cls):
+        return relationship(
+            'Repository',
+            primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
+
+    @property
+    def source_ref_parts(self):
+        refs = self.source_ref.split(':')
+        return Reference(refs[0], refs[1], refs[2])
+
+    @declared_attr
+    def target_repo(cls):
+        return relationship(
+            'Repository',
+            primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
+
+    @property
+    def target_ref_parts(self):
+        refs = self.target_ref.split(':')
+        return Reference(refs[0], refs[1], refs[2])
+
+
+class PullRequest(Base, _PullRequestBase):
+    __tablename__ = 'pull_requests'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    pull_request_id = Column(
+        'pull_request_id', Integer(), nullable=False, primary_key=True)
+
+    def __repr__(self):
+        if self.pull_request_id:
+            return '<DB:PullRequest #%s>' % self.pull_request_id
+        else:
+            return '<DB:PullRequest at %#x>' % id(self)
+
+    reviewers = relationship('PullRequestReviewers',
+                             cascade="all, delete, delete-orphan")
+    statuses = relationship('ChangesetStatus')
+    comments = relationship('ChangesetComment',
+                            cascade="all, delete, delete-orphan")
+    versions = relationship('PullRequestVersion',
+                            cascade="all, delete, delete-orphan")
+
+    def is_closed(self):
+        return self.status == self.STATUS_CLOSED
+
+    def get_api_data(self):
+        from rhodecode.model.pull_request import PullRequestModel
+        pull_request = self
+        merge_status = PullRequestModel().merge_status(pull_request)
+        data = {
+            'pull_request_id': pull_request.pull_request_id,
+            'url': url('pullrequest_show', repo_name=self.target_repo.repo_name,
+                                       pull_request_id=self.pull_request_id,
+                                       qualified=True),
+            'title': pull_request.title,
+            'description': pull_request.description,
+            'status': pull_request.status,
+            'created_on': pull_request.created_on,
+            'updated_on': pull_request.updated_on,
+            'commit_ids': pull_request.revisions,
+            'review_status': pull_request.calculated_review_status(),
+            'mergeable': {
+                'status': merge_status[0],
+                'message': unicode(merge_status[1]),
+            },
+            'source': {
+                'clone_url': pull_request.source_repo.clone_url(),
+                'repository': pull_request.source_repo.repo_name,
+                'reference': {
+                    'name': pull_request.source_ref_parts.name,
+                    'type': pull_request.source_ref_parts.type,
+                    'commit_id': pull_request.source_ref_parts.commit_id,
+                },
+            },
+            'target': {
+                'clone_url': pull_request.target_repo.clone_url(),
+                'repository': pull_request.target_repo.repo_name,
+                'reference': {
+                    'name': pull_request.target_ref_parts.name,
+                    'type': pull_request.target_ref_parts.type,
+                    'commit_id': pull_request.target_ref_parts.commit_id,
+                },
+            },
+            'author': pull_request.author.get_api_data(include_secrets=False,
+                                                       details='basic'),
+            'reviewers': [
+                {
+                    'user': reviewer.get_api_data(include_secrets=False,
+                                                  details='basic'),
+                    'review_status': st[0][1].status if st else 'not_reviewed',
+                }
+                for reviewer, st in pull_request.reviewers_statuses()
+            ]
+        }
+
+        return data
+
+    def __json__(self):
+        return {
+            'revisions': self.revisions,
+        }
+
+    def calculated_review_status(self):
+        # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
+        # because it's tricky on how to use ChangesetStatusModel from there
+        warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
+        from rhodecode.model.changeset_status import ChangesetStatusModel
+        return ChangesetStatusModel().calculated_review_status(self)
+
+    def reviewers_statuses(self):
+        warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
+        from rhodecode.model.changeset_status import ChangesetStatusModel
+        return ChangesetStatusModel().reviewers_statuses(self)
+
+
+class PullRequestVersion(Base, _PullRequestBase):
+    __tablename__ = 'pull_request_versions'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    pull_request_version_id = Column(
+        'pull_request_version_id', Integer(), nullable=False, primary_key=True)
+    pull_request_id = Column(
+        'pull_request_id', Integer(),
+        ForeignKey('pull_requests.pull_request_id'), nullable=False)
+    pull_request = relationship('PullRequest')
+
+    def __repr__(self):
+        if self.pull_request_version_id:
+            return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
+        else:
+            return '<DB:PullRequestVersion at %#x>' % id(self)
+
+
+class PullRequestReviewers(Base, BaseModel):
+    __tablename__ = 'pull_request_reviewers'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    def __init__(self, user=None, pull_request=None):
+        self.user = user
+        self.pull_request = pull_request
+
+    pull_requests_reviewers_id = Column(
+        'pull_requests_reviewers_id', Integer(), nullable=False,
+        primary_key=True)
+    pull_request_id = Column(
+        "pull_request_id", Integer(),
+        ForeignKey('pull_requests.pull_request_id'), nullable=False)
+    user_id = Column(
+        "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
+
+    user = relationship('User')
+    pull_request = relationship('PullRequest')
+
+
+class Notification(Base, BaseModel):
+    __tablename__ = 'notifications'
+    __table_args__ = (
+        Index('notification_type_idx', 'type'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    TYPE_CHANGESET_COMMENT = u'cs_comment'
+    TYPE_MESSAGE = u'message'
+    TYPE_MENTION = u'mention'
+    TYPE_REGISTRATION = u'registration'
+    TYPE_PULL_REQUEST = u'pull_request'
+    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
+
+    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
+    subject = Column('subject', Unicode(512), nullable=True)
+    body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
+    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    type_ = Column('type', Unicode(255))
+
+    created_by_user = relationship('User')
+    notifications_to_users = relationship('UserNotification', lazy='joined',
+                                          cascade="all, delete, delete-orphan")
+
+    @property
+    def recipients(self):
+        return [x.user for x in UserNotification.query()\
+                .filter(UserNotification.notification == self)\
+                .order_by(UserNotification.user_id.asc()).all()]
+
+    @classmethod
+    def create(cls, created_by, subject, body, recipients, type_=None):
+        if type_ is None:
+            type_ = Notification.TYPE_MESSAGE
+
+        notification = cls()
+        notification.created_by_user = created_by
+        notification.subject = subject
+        notification.body = body
+        notification.type_ = type_
+        notification.created_on = datetime.datetime.now()
+
+        for u in recipients:
+            assoc = UserNotification()
+            assoc.notification = notification
+
+            # if created_by is inside recipients mark his notification
+            # as read
+            if u.user_id == created_by.user_id:
+                assoc.read = True
+
+            u.notifications.append(assoc)
+        Session().add(notification)
+
+        return notification
+
+    @property
+    def description(self):
+        from rhodecode.model.notification import NotificationModel
+        return NotificationModel().make_description(self)
+
+
+class UserNotification(Base, BaseModel):
+    __tablename__ = 'user_to_notification'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'notification_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
+    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
+    read = Column('read', Boolean, default=False)
+    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
+
+    user = relationship('User', lazy="joined")
+    notification = relationship('Notification', lazy="joined",
+                                order_by=lambda: Notification.created_on.desc(),)
+
+    def mark_as_read(self):
+        self.read = True
+        Session().add(self)
+
+
+class Gist(Base, BaseModel):
+    __tablename__ = 'gists'
+    __table_args__ = (
+        Index('g_gist_access_id_idx', 'gist_access_id'),
+        Index('g_created_on_idx', 'created_on'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    GIST_PUBLIC = u'public'
+    GIST_PRIVATE = u'private'
+    DEFAULT_FILENAME = u'gistfile1.txt'
+
+    ACL_LEVEL_PUBLIC = u'acl_public'
+    ACL_LEVEL_PRIVATE = u'acl_private'
+
+    gist_id = Column('gist_id', Integer(), primary_key=True)
+    gist_access_id = Column('gist_access_id', Unicode(250))
+    gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
+    gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
+    gist_expires = Column('gist_expires', Float(53), nullable=False)
+    gist_type = Column('gist_type', Unicode(128), nullable=False)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    acl_level = Column('acl_level', Unicode(128), nullable=True)
+
+    owner = relationship('User')
+
+    def __repr__(self):
+        return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
+
+    @classmethod
+    def get_or_404(cls, id_):
+        res = cls.query().filter(cls.gist_access_id == id_).scalar()
+        if not res:
+            raise HTTPNotFound
+        return res
+
+    @classmethod
+    def get_by_access_id(cls, gist_access_id):
+        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
+
+    def gist_url(self):
+        import rhodecode
+        alias_url = rhodecode.CONFIG.get('gist_alias_url')
+        if alias_url:
+            return alias_url.replace('{gistid}', self.gist_access_id)
+
+        return url('gist', gist_id=self.gist_access_id, qualified=True)
+
+    @classmethod
+    def base_path(cls):
+        """
+        Returns base path when all gists are stored
+
+        :param cls:
+        """
+        from rhodecode.model.gist import GIST_STORE_LOC
+        q = Session().query(RhodeCodeUi)\
+            .filter(RhodeCodeUi.ui_key == URL_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return os.path.join(q.one().ui_value, GIST_STORE_LOC)
+
+    def get_api_data(self):
+        """
+        Common function for generating gist related data for API
+        """
+        gist = self
+        data = {
+            'gist_id': gist.gist_id,
+            'type': gist.gist_type,
+            'access_id': gist.gist_access_id,
+            'description': gist.gist_description,
+            'url': gist.gist_url(),
+            'expires': gist.gist_expires,
+            'created_on': gist.created_on,
+            'modified_at': gist.modified_at,
+            'content': None,
+            'acl_level': gist.acl_level,
+        }
+        return data
+
+    def __json__(self):
+        data = dict(
+        )
+        data.update(self.get_api_data())
+        return data
+    # SCM functions
+
+    def scm_instance(self, **kwargs):
+        full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
+        return get_vcs_instance(
+            repo_path=safe_str(full_repo_path), create=False)
+
+
+class DbMigrateVersion(Base, BaseModel):
+    __tablename__ = 'db_migrate_version'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    repository_id = Column('repository_id', String(250), primary_key=True)
+    repository_path = Column('repository_path', Text)
+    version = Column('version', Integer)
+
+
+class ExternalIdentity(Base, BaseModel):
+    __tablename__ = 'external_identities'
+    __table_args__ = (
+        Index('local_user_id_idx', 'local_user_id'),
+        Index('external_id_idx', 'external_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8'})
+
+    external_id = Column('external_id', Unicode(255), default=u'',
+                         primary_key=True)
+    external_username = Column('external_username', Unicode(1024), default=u'')
+    local_user_id = Column('local_user_id', Integer(),
+                           ForeignKey('users.user_id'), primary_key=True)
+    provider_name = Column('provider_name', Unicode(255), default=u'',
+                           primary_key=True)
+    access_token = Column('access_token', String(1024), default=u'')
+    alt_token = Column('alt_token', String(1024), default=u'')
+    token_secret = Column('token_secret', String(1024), default=u'')
+
+    @classmethod
+    def by_external_id_and_provider(cls, external_id, provider_name,
+                                    local_user_id=None):
+        """
+        Returns ExternalIdentity instance based on search params
+
+        :param external_id:
+        :param provider_name:
+        :return: ExternalIdentity
+        """
+        query = cls.query()
+        query = query.filter(cls.external_id == external_id)
+        query = query.filter(cls.provider_name == provider_name)
+        if local_user_id:
+            query = query.filter(cls.local_user_id == local_user_id)
+        return query.first()
+
+    @classmethod
+    def user_by_external_id_and_provider(cls, external_id, provider_name):
+        """
+        Returns User instance based on search params
+
+        :param external_id:
+        :param provider_name:
+        :return: User
+        """
+        query = User.query()
+        query = query.filter(cls.external_id == external_id)
+        query = query.filter(cls.provider_name == provider_name)
+        query = query.filter(User.user_id == cls.local_user_id)
+        return query.first()
+
+    @classmethod
+    def by_local_user_id(cls, local_user_id):
+        """
+        Returns all tokens for user
+
+        :param local_user_id:
+        :return: ExternalIdentity
+        """
+        query = cls.query()
+        query = query.filter(cls.local_user_id == local_user_id)
+        return query
+
+
+class Integration(Base, BaseModel):
+    __tablename__ = 'integrations'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    integration_id = Column('integration_id', Integer(), primary_key=True)
+    integration_type = Column('integration_type', String(255))
+    enabled = Column('enabled', Boolean(), nullable=False)
+    name = Column('name', String(255), nullable=False)
+    child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
+        default=False)
+
+    settings = Column(
+        'settings_json', MutationObj.as_mutable(
+            JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
+    repo_id = Column(
+        'repo_id', Integer(), ForeignKey('repositories.repo_id'),
+        nullable=True, unique=None, default=None)
+    repo = relationship('Repository', lazy='joined')
+
+    repo_group_id = Column(
+        'repo_group_id', Integer(), ForeignKey('groups.group_id'),
+        nullable=True, unique=None, default=None)
+    repo_group = relationship('RepoGroup', lazy='joined')
+
+    @property
+    def scope(self):
+        if self.repo:
+            return repr(self.repo)
+        if self.repo_group:
+            if self.child_repos_only:
+                return repr(self.repo_group) + ' (child repos only)'
+            else:
+                return repr(self.repo_group) + ' (recursive)'
+        if self.child_repos_only:
+            return 'root_repos'
+        return 'global'
+
+    def __repr__(self):
+        return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
+
+
+class RepoReviewRuleUser(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_user_id = Column(
+        'repo_review_rule_user_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
+        nullable=False)
+    user = relationship('User')
+
+
+class RepoReviewRuleUserGroup(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users_groups'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_users_group_id = Column(
+        'repo_review_rule_users_group_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    users_group_id = Column("users_group_id", Integer(),
+        ForeignKey('users_groups.users_group_id'), nullable=False)
+    users_group = relationship('UserGroup')
+
+
+class RepoReviewRule(Base, BaseModel):
+    __tablename__ = 'repo_review_rules'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+
+    repo_review_rule_id = Column(
+        'repo_review_rule_id', Integer(), primary_key=True)
+    repo_id = Column(
+        "repo_id", Integer(), ForeignKey('repositories.repo_id'))
+    repo = relationship('Repository', backref='review_rules')
+
+    _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+    _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+
+    use_authors_for_review = Column("use_authors_for_review", Boolean(),
+        nullable=False, default=False)
+    rule_users = relationship('RepoReviewRuleUser')
+    rule_user_groups = relationship('RepoReviewRuleUserGroup')
+
+    @hybrid_property
+    def branch_pattern(self):
+        return self._branch_pattern or '*'
+
+    def _validate_pattern(self, value):
+        re.compile('^' + glob2re(value) + '$')
+
+    @branch_pattern.setter
+    def branch_pattern(self, value):
+        self._validate_glob(value)
+        self._branch_pattern = value or '*'
+
+    @hybrid_property
+    def file_pattern(self):
+        return self._file_pattern or '*'
+
+    @file_pattern.setter
+    def file_pattern(self, value):
+        self._validate_glob(value)
+        self._file_pattern = value or '*'
+
+    def matches(self, branch, files_changed):
+        """
+        Check if this review rule matches a branch/files in a pull request
+
+        :param branch: branch name for the commit
+        :param files_changed: list of file paths changed in the pull request
+        """
+
+        branch = branch or ''
+        files_changed = files_changed or []
+
+        branch_matches = True
+        if branch:
+            branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
+            branch_matches = bool(branch_regex.search(branch))
+
+        files_matches = True
+        if self.file_pattern != '*':
+            files_matches = False
+            file_regex = re.compile(glob2re(self.file_pattern))
+            for filename in files_changed:
+                if file_regex.search(filename):
+                    files_matches = True
+                    break
+
+        return branch_matches and files_matches
+
+    @property
+    def review_users(self):
+        """ Returns the users which this rule applies to """
+
+        users = set()
+        users |= set([
+            rule_user.user for rule_user in self.rule_users
+            if rule_user.user.active])
+        users |= set(
+            member.user
+            for rule_user_group in self.rule_user_groups
+            for member in rule_user_group.users_group.members
+            if member.user.active
+        )
+        return users
+
+    def __repr__(self):
+        return '<RepoReviewerRule(id=%r, repo=%r)>' % (
+            self.repo_review_rule_id, self.repo)

rhodecode/lib/dbmigrate/schema/db_4_5_0_0.py

@@ -0,0 +1,3658 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+"""
+Database Models for RhodeCode Enterprise
+"""
+
+import re
+import os
+import sys
+import time
+import hashlib
+import logging
+import datetime
+import warnings
+import ipaddress
+import functools
+import traceback
+import collections
+
+
+from sqlalchemy import *
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.orm import (
+    relationship, joinedload, class_mapper, validates, aliased)
+from sqlalchemy.sql.expression import true
+from beaker.cache import cache_region, region_invalidate
+from webob.exc import HTTPNotFound
+from zope.cachedescriptors.property import Lazy as LazyProperty
+
+from pylons import url
+from pylons.i18n.translation import lazy_ugettext as _
+
+from rhodecode.lib.vcs import get_backend, get_vcs_instance
+from rhodecode.lib.vcs.utils.helpers import get_scm
+from rhodecode.lib.vcs.exceptions import VCSError
+from rhodecode.lib.vcs.backends.base import (
+    EmptyCommit, Reference, MergeFailureReason)
+from rhodecode.lib.utils2 import (
+    str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,
+    time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
+    glob2re)
+from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, JSONDict
+from rhodecode.lib.ext_json import json
+from rhodecode.lib.caching_query import FromCache
+from rhodecode.lib.encrypt import AESCipher
+
+from rhodecode.model.meta import Base, Session
+
+URL_SEP = '/'
+log = logging.getLogger(__name__)
+
+# =============================================================================
+# BASE CLASSES
+# =============================================================================
+
+# this is propagated from .ini file rhodecode.encrypted_values.secret or
+# beaker.session.secret if first is not set.
+# and initialized at environment.py
+ENCRYPTION_KEY = None
+
+# used to sort permissions by types, '#' used here is not allowed to be in
+# usernames, and it's very early in sorted string.printable table.
+PERMISSION_TYPE_SORT = {
+    'admin': '####',
+    'write': '###',
+    'read':  '##',
+    'none':  '#',
+}
+
+
+def display_sort(obj):
+    """
+    Sort function used to sort permissions in .permissions() function of
+    Repository, RepoGroup, UserGroup. Also it put the default user in front
+    of all other resources
+    """
+
+    if obj.username == User.DEFAULT_USER:
+        return '#####'
+    prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
+    return prefix + obj.username
+
+
+def _hash_key(k):
+    return md5_safe(k)
+
+
+class EncryptedTextValue(TypeDecorator):
+    """
+    Special column for encrypted long text data, use like::
+
+        value = Column("encrypted_value", EncryptedValue(), nullable=False)
+
+    This column is intelligent so if value is in unencrypted form it return
+    unencrypted form, but on save it always encrypts
+    """
+    impl = Text
+
+    def process_bind_param(self, value, dialect):
+        if not value:
+            return value
+        if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
+            # protect against double encrypting if someone manually starts
+            # doing
+            raise ValueError('value needs to be in unencrypted format, ie. '
+                             'not starting with enc$aes')
+        return 'enc$aes_hmac$%s' % AESCipher(
+            ENCRYPTION_KEY, hmac=True).encrypt(value)
+
+    def process_result_value(self, value, dialect):
+        import rhodecode
+
+        if not value:
+            return value
+
+        parts = value.split('$', 3)
+        if not len(parts) == 3:
+            # probably not encrypted values
+            return value
+        else:
+            if parts[0] != 'enc':
+                # parts ok but without our header ?
+                return value
+            enc_strict_mode = str2bool(rhodecode.CONFIG.get(
+                'rhodecode.encrypted_values.strict') or True)
+            # at that stage we know it's our encryption
+            if parts[1] == 'aes':
+                decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
+            elif parts[1] == 'aes_hmac':
+                decrypted_data = AESCipher(
+                    ENCRYPTION_KEY, hmac=True,
+                    strict_verification=enc_strict_mode).decrypt(parts[2])
+            else:
+                raise ValueError(
+                    'Encryption type part is wrong, must be `aes` '
+                    'or `aes_hmac`, got `%s` instead' % (parts[1]))
+            return decrypted_data
+
+
+class BaseModel(object):
+    """
+    Base Model for all classes
+    """
+
+    @classmethod
+    def _get_keys(cls):
+        """return column names for this model """
+        return class_mapper(cls).c.keys()
+
+    def get_dict(self):
+        """
+        return dict with keys and values corresponding
+        to this model data """
+
+        d = {}
+        for k in self._get_keys():
+            d[k] = getattr(self, k)
+
+        # also use __json__() if present to get additional fields
+        _json_attr = getattr(self, '__json__', None)
+        if _json_attr:
+            # update with attributes from __json__
+            if callable(_json_attr):
+                _json_attr = _json_attr()
+            for k, val in _json_attr.iteritems():
+                d[k] = val
+        return d
+
+    def get_appstruct(self):
+        """return list with keys and values tuples corresponding
+        to this model data """
+
+        l = []
+        for k in self._get_keys():
+            l.append((k, getattr(self, k),))
+        return l
+
+    def populate_obj(self, populate_dict):
+        """populate model with data from given populate_dict"""
+
+        for k in self._get_keys():
+            if k in populate_dict:
+                setattr(self, k, populate_dict[k])
+
+    @classmethod
+    def query(cls):
+        return Session().query(cls)
+
+    @classmethod
+    def get(cls, id_):
+        if id_:
+            return cls.query().get(id_)
+
+    @classmethod
+    def get_or_404(cls, id_):
+        try:
+            id_ = int(id_)
+        except (TypeError, ValueError):
+            raise HTTPNotFound
+
+        res = cls.query().get(id_)
+        if not res:
+            raise HTTPNotFound
+        return res
+
+    @classmethod
+    def getAll(cls):
+        # deprecated and left for backward compatibility
+        return cls.get_all()
+
+    @classmethod
+    def get_all(cls):
+        return cls.query().all()
+
+    @classmethod
+    def delete(cls, id_):
+        obj = cls.query().get(id_)
+        Session().delete(obj)
+
+    @classmethod
+    def identity_cache(cls, session, attr_name, value):
+        exist_in_session = []
+        for (item_cls, pkey), instance in session.identity_map.items():
+            if cls == item_cls and getattr(instance, attr_name) == value:
+                exist_in_session.append(instance)
+        if exist_in_session:
+            if len(exist_in_session) == 1:
+                return exist_in_session[0]
+            log.exception(
+                'multiple objects with attr %s and '
+                'value %s found with same name: %r',
+                attr_name, value, exist_in_session)
+
+    def __repr__(self):
+        if hasattr(self, '__unicode__'):
+            # python repr needs to return str
+            try:
+                return safe_str(self.__unicode__())
+            except UnicodeDecodeError:
+                pass
+        return '<DB:%s>' % (self.__class__.__name__)
+
+
+class RhodeCodeSetting(Base, BaseModel):
+    __tablename__ = 'rhodecode_settings'
+    __table_args__ = (
+        UniqueConstraint('app_settings_name'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    SETTINGS_TYPES = {
+        'str': safe_str,
+        'int': safe_int,
+        'unicode': safe_unicode,
+        'bool': str2bool,
+        'list': functools.partial(aslist, sep=',')
+    }
+    DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
+    GLOBAL_CONF_KEY = 'app_settings'
+
+    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
+    _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
+    _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
+
+    def __init__(self, key='', val='', type='unicode'):
+        self.app_settings_name = key
+        self.app_settings_type = type
+        self.app_settings_value = val
+
+    @validates('_app_settings_value')
+    def validate_settings_value(self, key, val):
+        assert type(val) == unicode
+        return val
+
+    @hybrid_property
+    def app_settings_value(self):
+        v = self._app_settings_value
+        _type = self.app_settings_type
+        if _type:
+            _type = self.app_settings_type.split('.')[0]
+            # decode the encrypted value
+            if 'encrypted' in self.app_settings_type:
+                cipher = EncryptedTextValue()
+                v = safe_unicode(cipher.process_result_value(v, None))
+
+        converter = self.SETTINGS_TYPES.get(_type) or \
+            self.SETTINGS_TYPES['unicode']
+        return converter(v)
+
+    @app_settings_value.setter
+    def app_settings_value(self, val):
+        """
+        Setter that will always make sure we use unicode in app_settings_value
+
+        :param val:
+        """
+        val = safe_unicode(val)
+        # encode the encrypted value
+        if 'encrypted' in self.app_settings_type:
+            cipher = EncryptedTextValue()
+            val = safe_unicode(cipher.process_bind_param(val, None))
+        self._app_settings_value = val
+
+    @hybrid_property
+    def app_settings_type(self):
+        return self._app_settings_type
+
+    @app_settings_type.setter
+    def app_settings_type(self, val):
+        if val.split('.')[0] not in self.SETTINGS_TYPES:
+            raise Exception('type must be one of %s got %s'
+                            % (self.SETTINGS_TYPES.keys(), val))
+        self._app_settings_type = val
+
+    def __unicode__(self):
+        return u"<%s('%s:%s[%s]')>" % (
+            self.__class__.__name__,
+            self.app_settings_name, self.app_settings_value,
+            self.app_settings_type
+        )
+
+
+class RhodeCodeUi(Base, BaseModel):
+    __tablename__ = 'rhodecode_ui'
+    __table_args__ = (
+        UniqueConstraint('ui_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    HOOK_REPO_SIZE = 'changegroup.repo_size'
+    # HG
+    HOOK_PRE_PULL = 'preoutgoing.pre_pull'
+    HOOK_PULL = 'outgoing.pull_logger'
+    HOOK_PRE_PUSH = 'prechangegroup.pre_push'
+    HOOK_PUSH = 'changegroup.push_logger'
+
+    # TODO: johbo: Unify way how hooks are configured for git and hg,
+    # git part is currently hardcoded.
+
+    # SVN PATTERNS
+    SVN_BRANCH_ID = 'vcs_svn_branch'
+    SVN_TAG_ID = 'vcs_svn_tag'
+
+    ui_id = Column(
+        "ui_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    ui_section = Column(
+        "ui_section", String(255), nullable=True, unique=None, default=None)
+    ui_key = Column(
+        "ui_key", String(255), nullable=True, unique=None, default=None)
+    ui_value = Column(
+        "ui_value", String(255), nullable=True, unique=None, default=None)
+    ui_active = Column(
+        "ui_active", Boolean(), nullable=True, unique=None, default=True)
+
+    def __repr__(self):
+        return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
+                                    self.ui_key, self.ui_value)
+
+
+class RepoRhodeCodeSetting(Base, BaseModel):
+    __tablename__ = 'repo_rhodecode_settings'
+    __table_args__ = (
+        UniqueConstraint(
+            'app_settings_name', 'repository_id',
+            name='uq_repo_rhodecode_setting_name_repo_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    repository_id = Column(
+        "repository_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=False)
+    app_settings_id = Column(
+        "app_settings_id", Integer(), nullable=False, unique=True,
+        default=None, primary_key=True)
+    app_settings_name = Column(
+        "app_settings_name", String(255), nullable=True, unique=None,
+        default=None)
+    _app_settings_value = Column(
+        "app_settings_value", String(4096), nullable=True, unique=None,
+        default=None)
+    _app_settings_type = Column(
+        "app_settings_type", String(255), nullable=True, unique=None,
+        default=None)
+
+    repository = relationship('Repository')
+
+    def __init__(self, repository_id, key='', val='', type='unicode'):
+        self.repository_id = repository_id
+        self.app_settings_name = key
+        self.app_settings_type = type
+        self.app_settings_value = val
+
+    @validates('_app_settings_value')
+    def validate_settings_value(self, key, val):
+        assert type(val) == unicode
+        return val
+
+    @hybrid_property
+    def app_settings_value(self):
+        v = self._app_settings_value
+        type_ = self.app_settings_type
+        SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
+        converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
+        return converter(v)
+
+    @app_settings_value.setter
+    def app_settings_value(self, val):
+        """
+        Setter that will always make sure we use unicode in app_settings_value
+
+        :param val:
+        """
+        self._app_settings_value = safe_unicode(val)
+
+    @hybrid_property
+    def app_settings_type(self):
+        return self._app_settings_type
+
+    @app_settings_type.setter
+    def app_settings_type(self, val):
+        SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
+        if val not in SETTINGS_TYPES:
+            raise Exception('type must be one of %s got %s'
+                            % (SETTINGS_TYPES.keys(), val))
+        self._app_settings_type = val
+
+    def __unicode__(self):
+        return u"<%s('%s:%s:%s[%s]')>" % (
+            self.__class__.__name__, self.repository.repo_name,
+            self.app_settings_name, self.app_settings_value,
+            self.app_settings_type
+        )
+
+
+class RepoRhodeCodeUi(Base, BaseModel):
+    __tablename__ = 'repo_rhodecode_ui'
+    __table_args__ = (
+        UniqueConstraint(
+            'repository_id', 'ui_section', 'ui_key',
+            name='uq_repo_rhodecode_ui_repository_id_section_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    repository_id = Column(
+        "repository_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=False)
+    ui_id = Column(
+        "ui_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    ui_section = Column(
+        "ui_section", String(255), nullable=True, unique=None, default=None)
+    ui_key = Column(
+        "ui_key", String(255), nullable=True, unique=None, default=None)
+    ui_value = Column(
+        "ui_value", String(255), nullable=True, unique=None, default=None)
+    ui_active = Column(
+        "ui_active", Boolean(), nullable=True, unique=None, default=True)
+
+    repository = relationship('Repository')
+
+    def __repr__(self):
+        return '<%s[%s:%s]%s=>%s]>' % (
+            self.__class__.__name__, self.repository.repo_name,
+            self.ui_section, self.ui_key, self.ui_value)
+
+
+class User(Base, BaseModel):
+    __tablename__ = 'users'
+    __table_args__ = (
+        UniqueConstraint('username'), UniqueConstraint('email'),
+        Index('u_username_idx', 'username'),
+        Index('u_email_idx', 'email'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    DEFAULT_USER = 'default'
+    DEFAULT_USER_EMAIL = '[e-mail]'
+    DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
+
+    user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    username = Column("username", String(255), nullable=True, unique=None, default=None)
+    password = Column("password", String(255), nullable=True, unique=None, default=None)
+    active = Column("active", Boolean(), nullable=True, unique=None, default=True)
+    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
+    name = Column("firstname", String(255), nullable=True, unique=None, default=None)
+    lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
+    _email = Column("email", String(255), nullable=True, unique=None, default=None)
+    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
+    extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
+    extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
+    api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
+    inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
+
+    user_log = relationship('UserLog')
+    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
+
+    repositories = relationship('Repository')
+    repository_groups = relationship('RepoGroup')
+    user_groups = relationship('UserGroup')
+
+    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
+    followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
+
+    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
+    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
+    user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
+
+    group_member = relationship('UserGroupMember', cascade='all')
+
+    notifications = relationship('UserNotification', cascade='all')
+    # notifications assigned to this user
+    user_created_notifications = relationship('Notification', cascade='all')
+    # comments created by this user
+    user_comments = relationship('ChangesetComment', cascade='all')
+    # user profile extra info
+    user_emails = relationship('UserEmailMap', cascade='all')
+    user_ip_map = relationship('UserIpMap', cascade='all')
+    user_auth_tokens = relationship('UserApiKeys', cascade='all')
+    # gists
+    user_gists = relationship('Gist', cascade='all')
+    # user pull requests
+    user_pull_requests = relationship('PullRequest', cascade='all')
+    # external identities
+    extenal_identities = relationship(
+        'ExternalIdentity',
+        primaryjoin="User.user_id==ExternalIdentity.local_user_id",
+        cascade='all')
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.user_id, self.username)
+
+    @hybrid_property
+    def email(self):
+        return self._email
+
+    @email.setter
+    def email(self, val):
+        self._email = val.lower() if val else None
+
+    @property
+    def firstname(self):
+        # alias for future
+        return self.name
+
+    @property
+    def emails(self):
+        other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
+        return [self.email] + [x.email for x in other]
+
+    @property
+    def auth_tokens(self):
+        return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
+
+    @property
+    def extra_auth_tokens(self):
+        return UserApiKeys.query().filter(UserApiKeys.user == self).all()
+
+    @property
+    def feed_token(self):
+        feed_tokens = UserApiKeys.query()\
+            .filter(UserApiKeys.user == self)\
+            .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
+            .all()
+        if feed_tokens:
+            return feed_tokens[0].api_key
+        else:
+            # use the main token so we don't end up with nothing...
+            return self.api_key
+
+    @classmethod
+    def extra_valid_auth_tokens(cls, user, role=None):
+        tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
+                .filter(or_(UserApiKeys.expires == -1,
+                            UserApiKeys.expires >= time.time()))
+        if role:
+            tokens = tokens.filter(or_(UserApiKeys.role == role,
+                                       UserApiKeys.role == UserApiKeys.ROLE_ALL))
+        return tokens.all()
+
+    @property
+    def ip_addresses(self):
+        ret = UserIpMap.query().filter(UserIpMap.user == self).all()
+        return [x.ip_addr for x in ret]
+
+    @property
+    def username_and_name(self):
+        return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
+
+    @property
+    def username_or_name_or_email(self):
+        full_name = self.full_name if self.full_name is not ' ' else None
+        return self.username or full_name or self.email
+
+    @property
+    def full_name(self):
+        return '%s %s' % (self.firstname, self.lastname)
+
+    @property
+    def full_name_or_username(self):
+        return ('%s %s' % (self.firstname, self.lastname)
+                if (self.firstname and self.lastname) else self.username)
+
+    @property
+    def full_contact(self):
+        return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
+
+    @property
+    def short_contact(self):
+        return '%s %s' % (self.firstname, self.lastname)
+
+    @property
+    def is_admin(self):
+        return self.admin
+
+    @property
+    def AuthUser(self):
+        """
+        Returns instance of AuthUser for this user
+        """
+        from rhodecode.lib.auth import AuthUser
+        return AuthUser(user_id=self.user_id, api_key=self.api_key,
+                        username=self.username)
+
+    @hybrid_property
+    def user_data(self):
+        if not self._user_data:
+            return {}
+
+        try:
+            return json.loads(self._user_data)
+        except TypeError:
+            return {}
+
+    @user_data.setter
+    def user_data(self, val):
+        if not isinstance(val, dict):
+            raise Exception('user_data must be dict, got %s' % type(val))
+        try:
+            self._user_data = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    @classmethod
+    def get_by_username(cls, username, case_insensitive=False,
+                        cache=False, identity_cache=False):
+        session = Session()
+
+        if case_insensitive:
+            q = cls.query().filter(
+                func.lower(cls.username) == func.lower(username))
+        else:
+            q = cls.query().filter(cls.username == username)
+
+        if cache:
+            if identity_cache:
+                val = cls.identity_cache(session, 'username', username)
+                if val:
+                    return val
+            else:
+                q = q.options(
+                    FromCache("sql_cache_short",
+                              "get_user_by_name_%s" % _hash_key(username)))
+
+        return q.scalar()
+
+    @classmethod
+    def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
+        q = cls.query().filter(cls.api_key == auth_token)
+
+        if cache:
+            q = q.options(FromCache("sql_cache_short",
+                                    "get_auth_token_%s" % auth_token))
+        res = q.scalar()
+
+        if fallback and not res:
+            #fallback to additional keys
+            _res = UserApiKeys.query()\
+                .filter(UserApiKeys.api_key == auth_token)\
+                .filter(or_(UserApiKeys.expires == -1,
+                            UserApiKeys.expires >= time.time()))\
+                .first()
+            if _res:
+                res = _res.user
+        return res
+
+    @classmethod
+    def get_by_email(cls, email, case_insensitive=False, cache=False):
+
+        if case_insensitive:
+            q = cls.query().filter(func.lower(cls.email) == func.lower(email))
+
+        else:
+            q = cls.query().filter(cls.email == email)
+
+        if cache:
+            q = q.options(FromCache("sql_cache_short",
+                                    "get_email_key_%s" % _hash_key(email)))
+
+        ret = q.scalar()
+        if ret is None:
+            q = UserEmailMap.query()
+            # try fetching in alternate email map
+            if case_insensitive:
+                q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
+            else:
+                q = q.filter(UserEmailMap.email == email)
+            q = q.options(joinedload(UserEmailMap.user))
+            if cache:
+                q = q.options(FromCache("sql_cache_short",
+                                        "get_email_map_key_%s" % email))
+            ret = getattr(q.scalar(), 'user', None)
+
+        return ret
+
+    @classmethod
+    def get_from_cs_author(cls, author):
+        """
+        Tries to get User objects out of commit author string
+
+        :param author:
+        """
+        from rhodecode.lib.helpers import email, author_name
+        # Valid email in the attribute passed, see if they're in the system
+        _email = email(author)
+        if _email:
+            user = cls.get_by_email(_email, case_insensitive=True)
+            if user:
+                return user
+        # Maybe we can match by username?
+        _author = author_name(author)
+        user = cls.get_by_username(_author, case_insensitive=True)
+        if user:
+            return user
+
+    def update_userdata(self, **kwargs):
+        usr = self
+        old = usr.user_data
+        old.update(**kwargs)
+        usr.user_data = old
+        Session().add(usr)
+        log.debug('updated userdata with ', kwargs)
+
+    def update_lastlogin(self):
+        """Update user lastlogin"""
+        self.last_login = datetime.datetime.now()
+        Session().add(self)
+        log.debug('updated user %s lastlogin', self.username)
+
+    def update_lastactivity(self):
+        """Update user lastactivity"""
+        usr = self
+        old = usr.user_data
+        old.update({'last_activity': time.time()})
+        usr.user_data = old
+        Session().add(usr)
+        log.debug('updated user %s lastactivity', usr.username)
+
+    def update_password(self, new_password, change_api_key=False):
+        from rhodecode.lib.auth import get_crypt_password,generate_auth_token
+
+        self.password = get_crypt_password(new_password)
+        if change_api_key:
+            self.api_key = generate_auth_token(self.username)
+        Session().add(self)
+
+    @classmethod
+    def get_first_super_admin(cls):
+        user = User.query().filter(User.admin == true()).first()
+        if user is None:
+            raise Exception('FATAL: Missing administrative account!')
+        return user
+
+    @classmethod
+    def get_all_super_admins(cls):
+        """
+        Returns all admin accounts sorted by username
+        """
+        return User.query().filter(User.admin == true())\
+            .order_by(User.username.asc()).all()
+
+    @classmethod
+    def get_default_user(cls, cache=False):
+        user = User.get_by_username(User.DEFAULT_USER, cache=cache)
+        if user is None:
+            raise Exception('FATAL: Missing default account!')
+        return user
+
+    def _get_default_perms(self, user, suffix=''):
+        from rhodecode.model.permission import PermissionModel
+        return PermissionModel().get_default_perms(user.user_perms, suffix)
+
+    def get_default_perms(self, suffix=''):
+        return self._get_default_perms(self, suffix)
+
+    def get_api_data(self, include_secrets=False, details='full'):
+        """
+        Common function for generating user related data for API
+
+        :param include_secrets: By default secrets in the API data will be replaced
+           by a placeholder value to prevent exposing this data by accident. In case
+           this data shall be exposed, set this flag to ``True``.
+
+        :param details: details can be 'basic|full' basic gives only a subset of
+           the available user information that includes user_id, name and emails.
+        """
+        user = self
+        user_data = self.user_data
+        data = {
+            'user_id': user.user_id,
+            'username': user.username,
+            'firstname': user.name,
+            'lastname': user.lastname,
+            'email': user.email,
+            'emails': user.emails,
+        }
+        if details == 'basic':
+            return data
+
+        api_key_length = 40
+        api_key_replacement = '*' * api_key_length
+
+        extras = {
+            'api_key': api_key_replacement,
+            'api_keys': [api_key_replacement],
+            'active': user.active,
+            'admin': user.admin,
+            'extern_type': user.extern_type,
+            'extern_name': user.extern_name,
+            'last_login': user.last_login,
+            'ip_addresses': user.ip_addresses,
+            'language': user_data.get('language')
+        }
+        data.update(extras)
+
+        if include_secrets:
+            data['api_key'] = user.api_key
+            data['api_keys'] = user.auth_tokens
+        return data
+
+    def __json__(self):
+        data = {
+            'full_name': self.full_name,
+            'full_name_or_username': self.full_name_or_username,
+            'short_contact': self.short_contact,
+            'full_contact': self.full_contact,
+        }
+        data.update(self.get_api_data())
+        return data
+
+
+class UserApiKeys(Base, BaseModel):
+    __tablename__ = 'user_api_keys'
+    __table_args__ = (
+        Index('uak_api_key_idx', 'api_key'),
+        Index('uak_api_key_expires_idx', 'api_key', 'expires'),
+        UniqueConstraint('api_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    # ApiKey role
+    ROLE_ALL = 'token_role_all'
+    ROLE_HTTP = 'token_role_http'
+    ROLE_VCS = 'token_role_vcs'
+    ROLE_API = 'token_role_api'
+    ROLE_FEED = 'token_role_feed'
+    ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
+
+    user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    api_key = Column("api_key", String(255), nullable=False, unique=True)
+    description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
+    expires = Column('expires', Float(53), nullable=False)
+    role = Column('role', String(255), nullable=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    user = relationship('User', lazy='joined')
+
+    @classmethod
+    def _get_role_name(cls, role):
+        return {
+            cls.ROLE_ALL: _('all'),
+            cls.ROLE_HTTP: _('http/web interface'),
+            cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
+            cls.ROLE_API: _('api calls'),
+            cls.ROLE_FEED: _('feed access'),
+        }.get(role, role)
+
+    @property
+    def expired(self):
+        if self.expires == -1:
+            return False
+        return time.time() > self.expires
+
+    @property
+    def role_humanized(self):
+        return self._get_role_name(self.role)
+
+
+class UserEmailMap(Base, BaseModel):
+    __tablename__ = 'user_email_map'
+    __table_args__ = (
+        Index('uem_email_idx', 'email'),
+        UniqueConstraint('email'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    _email = Column("email", String(255), nullable=True, unique=False, default=None)
+    user = relationship('User', lazy='joined')
+
+    @validates('_email')
+    def validate_email(self, key, email):
+        # check if this email is not main one
+        main_email = Session().query(User).filter(User.email == email).scalar()
+        if main_email is not None:
+            raise AttributeError('email %s is present is user table' % email)
+        return email
+
+    @hybrid_property
+    def email(self):
+        return self._email
+
+    @email.setter
+    def email(self, val):
+        self._email = val.lower() if val else None
+
+
+class UserIpMap(Base, BaseModel):
+    __tablename__ = 'user_ip_map'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'ip_addr'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    __mapper_args__ = {}
+
+    ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
+    active = Column("active", Boolean(), nullable=True, unique=None, default=True)
+    description = Column("description", String(10000), nullable=True, unique=None, default=None)
+    user = relationship('User', lazy='joined')
+
+    @classmethod
+    def _get_ip_range(cls, ip_addr):
+        net = ipaddress.ip_network(ip_addr, strict=False)
+        return [str(net.network_address), str(net.broadcast_address)]
+
+    def __json__(self):
+        return {
+          'ip_addr': self.ip_addr,
+          'ip_range': self._get_ip_range(self.ip_addr),
+        }
+
+    def __unicode__(self):
+        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
+                                            self.user_id, self.ip_addr)
+
+class UserLog(Base, BaseModel):
+    __tablename__ = 'user_logs'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    username = Column("username", String(255), nullable=True, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
+    repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
+    user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
+    action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
+    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.repository_name,
+                                      self.action)
+
+    @property
+    def action_as_day(self):
+        return datetime.date(*self.action_date.timetuple()[:3])
+
+    user = relationship('User')
+    repository = relationship('Repository', cascade='')
+
+
+class UserGroup(Base, BaseModel):
+    __tablename__ = 'users_groups'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
+    user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
+    users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
+    inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
+
+    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
+    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
+    users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
+    user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
+    user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
+
+    user = relationship('User')
+
+    @hybrid_property
+    def group_data(self):
+        if not self._group_data:
+            return {}
+
+        try:
+            return json.loads(self._group_data)
+        except TypeError:
+            return {}
+
+    @group_data.setter
+    def group_data(self, val):
+        try:
+            self._group_data = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                      self.users_group_id,
+                                      self.users_group_name)
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False,
+                          case_insensitive=False):
+        if case_insensitive:
+            q = cls.query().filter(func.lower(cls.users_group_name) ==
+                                   func.lower(group_name))
+
+        else:
+            q = cls.query().filter(cls.users_group_name == group_name)
+        if cache:
+            q = q.options(FromCache(
+                            "sql_cache_short",
+                            "get_group_%s" % _hash_key(group_name)))
+        return q.scalar()
+
+    @classmethod
+    def get(cls, user_group_id, cache=False):
+        user_group = cls.query()
+        if cache:
+            user_group = user_group.options(FromCache("sql_cache_short",
+                                    "get_users_group_%s" % user_group_id))
+        return user_group.get(user_group_id)
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
+        q = q.options(joinedload(UserUserGroupToPerm.user_group),
+                      joinedload(UserUserGroupToPerm.user),
+                      joinedload(UserUserGroupToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'usergroup.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
+        q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
+                      joinedload(UserGroupUserGroupToPerm.target_user_group),
+                      joinedload(UserGroupUserGroupToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.user_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def _get_default_perms(self, user_group, suffix=''):
+        from rhodecode.model.permission import PermissionModel
+        return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
+
+    def get_default_perms(self, suffix=''):
+        return self._get_default_perms(self, suffix)
+
+    def get_api_data(self, with_group_members=True, include_secrets=False):
+        """
+        :param include_secrets: See :meth:`User.get_api_data`, this parameter is
+           basically forwarded.
+
+        """
+        user_group = self
+
+        data = {
+            'users_group_id': user_group.users_group_id,
+            'group_name': user_group.users_group_name,
+            'group_description': user_group.user_group_description,
+            'active': user_group.users_group_active,
+            'owner': user_group.user.username,
+        }
+        if with_group_members:
+            users = []
+            for user in user_group.members:
+                user = user.user
+                users.append(user.get_api_data(include_secrets=include_secrets))
+            data['users'] = users
+
+        return data
+
+
+class UserGroupMember(Base, BaseModel):
+    __tablename__ = 'users_groups_members'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User', lazy='joined')
+    users_group = relationship('UserGroup')
+
+    def __init__(self, gr_id='', u_id=''):
+        self.users_group_id = gr_id
+        self.user_id = u_id
+
+
+class RepositoryField(Base, BaseModel):
+    __tablename__ = 'repositories_fields'
+    __table_args__ = (
+        UniqueConstraint('repository_id', 'field_key'),  # no-multi field
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields
+
+    repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+    field_key = Column("field_key", String(250))
+    field_label = Column("field_label", String(1024), nullable=False)
+    field_value = Column("field_value", String(10000), nullable=False)
+    field_desc = Column("field_desc", String(1024), nullable=False)
+    field_type = Column("field_type", String(255), nullable=False, unique=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    repository = relationship('Repository')
+
+    @property
+    def field_key_prefixed(self):
+        return 'ex_%s' % self.field_key
+
+    @classmethod
+    def un_prefix_key(cls, key):
+        if key.startswith(cls.PREFIX):
+            return key[len(cls.PREFIX):]
+        return key
+
+    @classmethod
+    def get_by_key_name(cls, key, repo):
+        row = cls.query()\
+                .filter(cls.repository == repo)\
+                .filter(cls.field_key == key).scalar()
+        return row
+
+
+class Repository(Base, BaseModel):
+    __tablename__ = 'repositories'
+    __table_args__ = (
+        Index('r_repo_name_idx', 'repo_name', mysql_length=255),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
+    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
+
+    STATE_CREATED = 'repo_state_created'
+    STATE_PENDING = 'repo_state_pending'
+    STATE_ERROR = 'repo_state_error'
+
+    LOCK_AUTOMATIC = 'lock_auto'
+    LOCK_API = 'lock_api'
+    LOCK_WEB = 'lock_web'
+    LOCK_PULL = 'lock_pull'
+
+    NAME_SEP = URL_SEP
+
+    repo_id = Column(
+        "repo_id", Integer(), nullable=False, unique=True, default=None,
+        primary_key=True)
+    _repo_name = Column(
+        "repo_name", Text(), nullable=False, default=None)
+    _repo_name_hash = Column(
+        "repo_name_hash", String(255), nullable=False, unique=True)
+    repo_state = Column("repo_state", String(255), nullable=True)
+
+    clone_uri = Column(
+        "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
+        default=None)
+    repo_type = Column(
+        "repo_type", String(255), nullable=False, unique=False, default=None)
+    user_id = Column(
+        "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
+        unique=False, default=None)
+    private = Column(
+        "private", Boolean(), nullable=True, unique=None, default=None)
+    enable_statistics = Column(
+        "statistics", Boolean(), nullable=True, unique=None, default=True)
+    enable_downloads = Column(
+        "downloads", Boolean(), nullable=True, unique=None, default=True)
+    description = Column(
+        "description", String(10000), nullable=True, unique=None, default=None)
+    created_on = Column(
+        'created_on', DateTime(timezone=False), nullable=True, unique=None,
+        default=datetime.datetime.now)
+    updated_on = Column(
+        'updated_on', DateTime(timezone=False), nullable=True, unique=None,
+        default=datetime.datetime.now)
+    _landing_revision = Column(
+        "landing_revision", String(255), nullable=False, unique=False,
+        default=None)
+    enable_locking = Column(
+        "enable_locking", Boolean(), nullable=False, unique=None,
+        default=False)
+    _locked = Column(
+        "locked", String(255), nullable=True, unique=False, default=None)
+    _changeset_cache = Column(
+        "changeset_cache", LargeBinary(), nullable=True)  # JSON data
+
+    fork_id = Column(
+        "fork_id", Integer(), ForeignKey('repositories.repo_id'),
+        nullable=True, unique=False, default=None)
+    group_id = Column(
+        "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
+        unique=False, default=None)
+
+    user = relationship('User', lazy='joined')
+    fork = relationship('Repository', remote_side=repo_id, lazy='joined')
+    group = relationship('RepoGroup', lazy='joined')
+    repo_to_perm = relationship(
+        'UserRepoToPerm', cascade='all',
+        order_by='UserRepoToPerm.repo_to_perm_id')
+    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
+    stats = relationship('Statistics', cascade='all', uselist=False)
+
+    followers = relationship(
+        'UserFollowing',
+        primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
+        cascade='all')
+    extra_fields = relationship(
+        'RepositoryField', cascade="all, delete, delete-orphan")
+    logs = relationship('UserLog')
+    comments = relationship(
+        'ChangesetComment', cascade="all, delete, delete-orphan")
+    pull_requests_source = relationship(
+        'PullRequest',
+        primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
+        cascade="all, delete, delete-orphan")
+    pull_requests_target = relationship(
+        'PullRequest',
+        primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
+        cascade="all, delete, delete-orphan")
+    ui = relationship('RepoRhodeCodeUi', cascade="all")
+    settings = relationship('RepoRhodeCodeSetting', cascade="all")
+    integrations = relationship('Integration',
+                                cascade="all, delete, delete-orphan")
+
+    def __unicode__(self):
+        return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
+                                   safe_unicode(self.repo_name))
+
+    @hybrid_property
+    def landing_rev(self):
+        # always should return [rev_type, rev]
+        if self._landing_revision:
+            _rev_info = self._landing_revision.split(':')
+            if len(_rev_info) < 2:
+                _rev_info.insert(0, 'rev')
+            return [_rev_info[0], _rev_info[1]]
+        return [None, None]
+
+    @landing_rev.setter
+    def landing_rev(self, val):
+        if ':' not in val:
+            raise ValueError('value must be delimited with `:` and consist '
+                             'of <rev_type>:<rev>, got %s instead' % val)
+        self._landing_revision = val
+
+    @hybrid_property
+    def locked(self):
+        if self._locked:
+            user_id, timelocked, reason = self._locked.split(':')
+            lock_values = int(user_id), timelocked, reason
+        else:
+            lock_values = [None, None, None]
+        return lock_values
+
+    @locked.setter
+    def locked(self, val):
+        if val and isinstance(val, (list, tuple)):
+            self._locked = ':'.join(map(str, val))
+        else:
+            self._locked = None
+
+    @hybrid_property
+    def changeset_cache(self):
+        from rhodecode.lib.vcs.backends.base import EmptyCommit
+        dummy = EmptyCommit().__json__()
+        if not self._changeset_cache:
+            return dummy
+        try:
+            return json.loads(self._changeset_cache)
+        except TypeError:
+            return dummy
+        except Exception:
+            log.error(traceback.format_exc())
+            return dummy
+
+    @changeset_cache.setter
+    def changeset_cache(self, val):
+        try:
+            self._changeset_cache = json.dumps(val)
+        except Exception:
+            log.error(traceback.format_exc())
+
+    @hybrid_property
+    def repo_name(self):
+        return self._repo_name
+
+    @repo_name.setter
+    def repo_name(self, value):
+        self._repo_name = value
+        self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
+
+    @classmethod
+    def normalize_repo_name(cls, repo_name):
+        """
+        Normalizes os specific repo_name to the format internally stored inside
+        database using URL_SEP
+
+        :param cls:
+        :param repo_name:
+        """
+        return cls.NAME_SEP.join(repo_name.split(os.sep))
+
+    @classmethod
+    def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
+        session = Session()
+        q = session.query(cls).filter(cls.repo_name == repo_name)
+
+        if cache:
+            if identity_cache:
+                val = cls.identity_cache(session, 'repo_name', repo_name)
+                if val:
+                    return val
+            else:
+                q = q.options(
+                    FromCache("sql_cache_short",
+                              "get_repo_by_name_%s" % _hash_key(repo_name)))
+
+        return q.scalar()
+
+    @classmethod
+    def get_by_full_path(cls, repo_full_path):
+        repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
+        repo_name = cls.normalize_repo_name(repo_name)
+        return cls.get_by_repo_name(repo_name.strip(URL_SEP))
+
+    @classmethod
+    def get_repo_forks(cls, repo_id):
+        return cls.query().filter(Repository.fork_id == repo_id)
+
+    @classmethod
+    def base_path(cls):
+        """
+        Returns base path when all repos are stored
+
+        :param cls:
+        """
+        q = Session().query(RhodeCodeUi)\
+            .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @classmethod
+    def is_valid(cls, repo_name):
+        """
+        returns True if given repo name is a valid filesystem repository
+
+        :param cls:
+        :param repo_name:
+        """
+        from rhodecode.lib.utils import is_valid_repo
+
+        return is_valid_repo(repo_name, cls.base_path())
+
+    @classmethod
+    def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
+                      case_insensitive=True):
+        q = Repository.query()
+
+        if not isinstance(user_id, Optional):
+            q = q.filter(Repository.user_id == user_id)
+
+        if not isinstance(group_id, Optional):
+            q = q.filter(Repository.group_id == group_id)
+
+        if case_insensitive:
+            q = q.order_by(func.lower(Repository.repo_name))
+        else:
+            q = q.order_by(Repository.repo_name)
+        return q.all()
+
+    @property
+    def forks(self):
+        """
+        Return forks of this repo
+        """
+        return Repository.get_repo_forks(self.repo_id)
+
+    @property
+    def parent(self):
+        """
+        Returns fork parent
+        """
+        return self.fork
+
+    @property
+    def just_name(self):
+        return self.repo_name.split(self.NAME_SEP)[-1]
+
+    @property
+    def groups_with_parents(self):
+        groups = []
+        if self.group is None:
+            return groups
+
+        cur_gr = self.group
+        groups.insert(0, cur_gr)
+        while 1:
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            groups.insert(0, gr)
+
+        return groups
+
+    @property
+    def groups_and_repo(self):
+        return self.groups_with_parents, self
+
+    @LazyProperty
+    def repo_path(self):
+        """
+        Returns base full path for that repository means where it actually
+        exists on a filesystem
+        """
+        q = Session().query(RhodeCodeUi).filter(
+            RhodeCodeUi.ui_key == self.NAME_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @property
+    def repo_full_path(self):
+        p = [self.repo_path]
+        # we need to split the name by / since this is how we store the
+        # names in the database, but that eventually needs to be converted
+        # into a valid system path
+        p += self.repo_name.split(self.NAME_SEP)
+        return os.path.join(*map(safe_unicode, p))
+
+    @property
+    def cache_keys(self):
+        """
+        Returns associated cache keys for that repo
+        """
+        return CacheKey.query()\
+            .filter(CacheKey.cache_args == self.repo_name)\
+            .order_by(CacheKey.cache_key)\
+            .all()
+
+    def get_new_name(self, repo_name):
+        """
+        returns new full repository name based on assigned group and new new
+
+        :param group_name:
+        """
+        path_prefix = self.group.full_path_splitted if self.group else []
+        return self.NAME_SEP.join(path_prefix + [repo_name])
+
+    @property
+    def _config(self):
+        """
+        Returns db based config object.
+        """
+        from rhodecode.lib.utils import make_db_config
+        return make_db_config(clear_session=False, repo=self)
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
+        q = q.options(joinedload(UserRepoToPerm.repository),
+                      joinedload(UserRepoToPerm.user),
+                      joinedload(UserRepoToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'repository.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupRepoToPerm.query().filter(
+            UserGroupRepoToPerm.repository == self)
+        q = q.options(joinedload(UserGroupRepoToPerm.repository),
+                      joinedload(UserGroupRepoToPerm.users_group),
+                      joinedload(UserGroupRepoToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.users_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def get_api_data(self, include_secrets=False):
+        """
+        Common function for generating repo api data
+
+        :param include_secrets: See :meth:`User.get_api_data`.
+
+        """
+        # TODO: mikhail: Here there is an anti-pattern, we probably need to
+        # move this methods on models level.
+        from rhodecode.model.settings import SettingsModel
+
+        repo = self
+        _user_id, _time, _reason = self.locked
+
+        data = {
+            'repo_id': repo.repo_id,
+            'repo_name': repo.repo_name,
+            'repo_type': repo.repo_type,
+            'clone_uri': repo.clone_uri or '',
+            'url': url('summary_home', repo_name=self.repo_name, qualified=True),
+            'private': repo.private,
+            'created_on': repo.created_on,
+            'description': repo.description,
+            'landing_rev': repo.landing_rev,
+            'owner': repo.user.username,
+            'fork_of': repo.fork.repo_name if repo.fork else None,
+            'enable_statistics': repo.enable_statistics,
+            'enable_locking': repo.enable_locking,
+            'enable_downloads': repo.enable_downloads,
+            'last_changeset': repo.changeset_cache,
+            'locked_by': User.get(_user_id).get_api_data(
+                include_secrets=include_secrets) if _user_id else None,
+            'locked_date': time_to_datetime(_time) if _time else None,
+            'lock_reason': _reason if _reason else None,
+        }
+
+        # TODO: mikhail: should be per-repo settings here
+        rc_config = SettingsModel().get_all_settings()
+        repository_fields = str2bool(
+            rc_config.get('rhodecode_repository_fields'))
+        if repository_fields:
+            for f in self.extra_fields:
+                data[f.field_key_prefixed] = f.field_value
+
+        return data
+
+    @classmethod
+    def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
+        if not lock_time:
+            lock_time = time.time()
+        if not lock_reason:
+            lock_reason = cls.LOCK_AUTOMATIC
+        repo.locked = [user_id, lock_time, lock_reason]
+        Session().add(repo)
+        Session().commit()
+
+    @classmethod
+    def unlock(cls, repo):
+        repo.locked = None
+        Session().add(repo)
+        Session().commit()
+
+    @classmethod
+    def getlock(cls, repo):
+        return repo.locked
+
+    def is_user_lock(self, user_id):
+        if self.lock[0]:
+            lock_user_id = safe_int(self.lock[0])
+            user_id = safe_int(user_id)
+            # both are ints, and they are equal
+            return all([lock_user_id, user_id]) and lock_user_id == user_id
+
+        return False
+
+    def get_locking_state(self, action, user_id, only_when_enabled=True):
+        """
+        Checks locking on this repository, if locking is enabled and lock is
+        present returns a tuple of make_lock, locked, locked_by.
+        make_lock can have 3 states None (do nothing) True, make lock
+        False release lock, This value is later propagated to hooks, which
+        do the locking. Think about this as signals passed to hooks what to do.
+
+        """
+        # TODO: johbo: This is part of the business logic and should be moved
+        # into the RepositoryModel.
+
+        if action not in ('push', 'pull'):
+            raise ValueError("Invalid action value: %s" % repr(action))
+
+        # defines if locked error should be thrown to user
+        currently_locked = False
+        # defines if new lock should be made, tri-state
+        make_lock = None
+        repo = self
+        user = User.get(user_id)
+
+        lock_info = repo.locked
+
+        if repo and (repo.enable_locking or not only_when_enabled):
+            if action == 'push':
+                # check if it's already locked !, if it is compare users
+                locked_by_user_id = lock_info[0]
+                if user.user_id == locked_by_user_id:
+                    log.debug(
+                        'Got `push` action from user %s, now unlocking', user)
+                    # unlock if we have push from user who locked
+                    make_lock = False
+                else:
+                    # we're not the same user who locked, ban with
+                    # code defined in settings (default is 423 HTTP Locked) !
+                    log.debug('Repo %s is currently locked by %s', repo, user)
+                    currently_locked = True
+            elif action == 'pull':
+                # [0] user [1] date
+                if lock_info[0] and lock_info[1]:
+                    log.debug('Repo %s is currently locked by %s', repo, user)
+                    currently_locked = True
+                else:
+                    log.debug('Setting lock on repo %s by %s', repo, user)
+                    make_lock = True
+
+        else:
+            log.debug('Repository %s do not have locking enabled', repo)
+
+        log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
+                  make_lock, currently_locked, lock_info)
+
+        from rhodecode.lib.auth import HasRepoPermissionAny
+        perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
+        if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
+            # if we don't have at least write permission we cannot make a lock
+            log.debug('lock state reset back to FALSE due to lack '
+                      'of at least read permission')
+            make_lock = False
+
+        return make_lock, currently_locked, lock_info
+
+    @property
+    def last_db_change(self):
+        return self.updated_on
+
+    @property
+    def clone_uri_hidden(self):
+        clone_uri = self.clone_uri
+        if clone_uri:
+            import urlobject
+            url_obj = urlobject.URLObject(clone_uri)
+            if url_obj.password:
+                clone_uri = url_obj.with_password('*****')
+        return clone_uri
+
+    def clone_url(self, **override):
+        qualified_home_url = url('home', qualified=True)
+
+        uri_tmpl = None
+        if 'with_id' in override:
+            uri_tmpl = self.DEFAULT_CLONE_URI_ID
+            del override['with_id']
+
+        if 'uri_tmpl' in override:
+            uri_tmpl = override['uri_tmpl']
+            del override['uri_tmpl']
+
+        # we didn't override our tmpl from **overrides
+        if not uri_tmpl:
+            uri_tmpl = self.DEFAULT_CLONE_URI
+            try:
+                from pylons import tmpl_context as c
+                uri_tmpl = c.clone_uri_tmpl
+            except Exception:
+                # in any case if we call this outside of request context,
+                # ie, not having tmpl_context set up
+                pass
+
+        return get_clone_url(uri_tmpl=uri_tmpl,
+                             qualifed_home_url=qualified_home_url,
+                             repo_name=self.repo_name,
+                             repo_id=self.repo_id, **override)
+
+    def set_state(self, state):
+        self.repo_state = state
+        Session().add(self)
+    #==========================================================================
+    # SCM PROPERTIES
+    #==========================================================================
+
+    def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
+        return get_commit_safe(
+            self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
+
+    def get_changeset(self, rev=None, pre_load=None):
+        warnings.warn("Use get_commit", DeprecationWarning)
+        commit_id = None
+        commit_idx = None
+        if isinstance(rev, basestring):
+            commit_id = rev
+        else:
+            commit_idx = rev
+        return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
+                               pre_load=pre_load)
+
+    def get_landing_commit(self):
+        """
+        Returns landing commit, or if that doesn't exist returns the tip
+        """
+        _rev_type, _rev = self.landing_rev
+        commit = self.get_commit(_rev)
+        if isinstance(commit, EmptyCommit):
+            return self.get_commit()
+        return commit
+
+    def update_commit_cache(self, cs_cache=None, config=None):
+        """
+        Update cache of last changeset for repository, keys should be::
+
+            short_id
+            raw_id
+            revision
+            parents
+            message
+            date
+            author
+
+        :param cs_cache:
+        """
+        from rhodecode.lib.vcs.backends.base import BaseChangeset
+        if cs_cache is None:
+            # use no-cache version here
+            scm_repo = self.scm_instance(cache=False, config=config)
+            if scm_repo:
+                cs_cache = scm_repo.get_commit(
+                    pre_load=["author", "date", "message", "parents"])
+            else:
+                cs_cache = EmptyCommit()
+
+        if isinstance(cs_cache, BaseChangeset):
+            cs_cache = cs_cache.__json__()
+
+        def is_outdated(new_cs_cache):
+            if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
+                new_cs_cache['revision'] != self.changeset_cache['revision']):
+                return True
+            return False
+
+        # check if we have maybe already latest cached revision
+        if is_outdated(cs_cache) or not self.changeset_cache:
+            _default = datetime.datetime.fromtimestamp(0)
+            last_change = cs_cache.get('date') or _default
+            log.debug('updated repo %s with new cs cache %s',
+                      self.repo_name, cs_cache)
+            self.updated_on = last_change
+            self.changeset_cache = cs_cache
+            Session().add(self)
+            Session().commit()
+        else:
+            log.debug('Skipping update_commit_cache for repo:`%s` '
+                      'commit already with latest changes', self.repo_name)
+
+    @property
+    def tip(self):
+        return self.get_commit('tip')
+
+    @property
+    def author(self):
+        return self.tip.author
+
+    @property
+    def last_change(self):
+        return self.scm_instance().last_change
+
+    def get_comments(self, revisions=None):
+        """
+        Returns comments for this repository grouped by revisions
+
+        :param revisions: filter query by revisions only
+        """
+        cmts = ChangesetComment.query()\
+            .filter(ChangesetComment.repo == self)
+        if revisions:
+            cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
+        grouped = collections.defaultdict(list)
+        for cmt in cmts.all():
+            grouped[cmt.revision].append(cmt)
+        return grouped
+
+    def statuses(self, revisions=None):
+        """
+        Returns statuses for this repository
+
+        :param revisions: list of revisions to get statuses for
+        """
+        statuses = ChangesetStatus.query()\
+            .filter(ChangesetStatus.repo == self)\
+            .filter(ChangesetStatus.version == 0)
+
+        if revisions:
+            # Try doing the filtering in chunks to avoid hitting limits
+            size = 500
+            status_results = []
+            for chunk in xrange(0, len(revisions), size):
+                status_results += statuses.filter(
+                    ChangesetStatus.revision.in_(
+                        revisions[chunk: chunk+size])
+                ).all()
+        else:
+            status_results = statuses.all()
+
+        grouped = {}
+
+        # maybe we have open new pullrequest without a status?
+        stat = ChangesetStatus.STATUS_UNDER_REVIEW
+        status_lbl = ChangesetStatus.get_status_lbl(stat)
+        for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
+            for rev in pr.revisions:
+                pr_id = pr.pull_request_id
+                pr_repo = pr.target_repo.repo_name
+                grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
+
+        for stat in status_results:
+            pr_id = pr_repo = None
+            if stat.pull_request:
+                pr_id = stat.pull_request.pull_request_id
+                pr_repo = stat.pull_request.target_repo.repo_name
+            grouped[stat.revision] = [str(stat.status), stat.status_lbl,
+                                      pr_id, pr_repo]
+        return grouped
+
+    # ==========================================================================
+    # SCM CACHE INSTANCE
+    # ==========================================================================
+
+    def scm_instance(self, **kwargs):
+        import rhodecode
+
+        # Passing a config will not hit the cache currently only used
+        # for repo2dbmapper
+        config = kwargs.pop('config', None)
+        cache = kwargs.pop('cache', None)
+        full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
+        # if cache is NOT defined use default global, else we have a full
+        # control over cache behaviour
+        if cache is None and full_cache and not config:
+            return self._get_instance_cached()
+        return self._get_instance(cache=bool(cache), config=config)
+
+    def _get_instance_cached(self):
+        @cache_region('long_term')
+        def _get_repo(cache_key):
+            return self._get_instance()
+
+        invalidator_context = CacheKey.repo_context_cache(
+            _get_repo, self.repo_name, None, thread_scoped=True)
+
+        with invalidator_context as context:
+            context.invalidate()
+            repo = context.compute()
+
+        return repo
+
+    def _get_instance(self, cache=True, config=None):
+        config = config or self._config
+        custom_wire = {
+            'cache': cache  # controls the vcs.remote cache
+        }
+
+        repo = get_vcs_instance(
+            repo_path=safe_str(self.repo_full_path),
+            config=config,
+            with_wire=custom_wire,
+            create=False)
+
+        return repo
+
+    def __json__(self):
+        return {'landing_rev': self.landing_rev}
+
+    def get_dict(self):
+
+        # Since we transformed `repo_name` to a hybrid property, we need to
+        # keep compatibility with the code which uses `repo_name` field.
+
+        result = super(Repository, self).get_dict()
+        result['repo_name'] = result.pop('_repo_name', None)
+        return result
+
+
+class RepoGroup(Base, BaseModel):
+    __tablename__ = 'groups'
+    __table_args__ = (
+        UniqueConstraint('group_name', 'group_parent_id'),
+        CheckConstraint('group_id != group_parent_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    __mapper_args__ = {'order_by': 'group_name'}
+
+    CHOICES_SEPARATOR = '/'  # used to generate select2 choices for nested groups
+
+    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
+    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
+    group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
+    enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+
+    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
+    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
+    parent_group = relationship('RepoGroup', remote_side=group_id)
+    user = relationship('User')
+    integrations = relationship('Integration',
+                                cascade="all, delete, delete-orphan")
+
+    def __init__(self, group_name='', parent_group=None):
+        self.group_name = group_name
+        self.parent_group = parent_group
+
+    def __unicode__(self):
+        return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
+                                      self.group_name)
+
+    @classmethod
+    def _generate_choice(cls, repo_group):
+        from webhelpers.html import literal as _literal
+        _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
+        return repo_group.group_id, _name(repo_group.full_path_splitted)
+
+    @classmethod
+    def groups_choices(cls, groups=None, show_empty_group=True):
+        if not groups:
+            groups = cls.query().all()
+
+        repo_groups = []
+        if show_empty_group:
+            repo_groups = [('-1', u'-- %s --' % _('No parent'))]
+
+        repo_groups.extend([cls._generate_choice(x) for x in groups])
+
+        repo_groups = sorted(
+            repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
+        return repo_groups
+
+    @classmethod
+    def url_sep(cls):
+        return URL_SEP
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
+        if case_insensitive:
+            gr = cls.query().filter(func.lower(cls.group_name)
+                                    == func.lower(group_name))
+        else:
+            gr = cls.query().filter(cls.group_name == group_name)
+        if cache:
+            gr = gr.options(FromCache(
+                            "sql_cache_short",
+                            "get_group_%s" % _hash_key(group_name)))
+        return gr.scalar()
+
+    @classmethod
+    def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
+                            case_insensitive=True):
+        q = RepoGroup.query()
+
+        if not isinstance(user_id, Optional):
+            q = q.filter(RepoGroup.user_id == user_id)
+
+        if not isinstance(group_id, Optional):
+            q = q.filter(RepoGroup.group_parent_id == group_id)
+
+        if case_insensitive:
+            q = q.order_by(func.lower(RepoGroup.group_name))
+        else:
+            q = q.order_by(RepoGroup.group_name)
+        return q.all()
+
+    @property
+    def parents(self):
+        parents_recursion_limit = 10
+        groups = []
+        if self.parent_group is None:
+            return groups
+        cur_gr = self.parent_group
+        groups.insert(0, cur_gr)
+        cnt = 0
+        while 1:
+            cnt += 1
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            if cnt == parents_recursion_limit:
+                # this will prevent accidental infinit loops
+                log.error(('more than %s parents found for group %s, stopping '
+                           'recursive parent fetching' % (parents_recursion_limit, self)))
+                break
+
+            groups.insert(0, gr)
+        return groups
+
+    @property
+    def children(self):
+        return RepoGroup.query().filter(RepoGroup.parent_group == self)
+
+    @property
+    def name(self):
+        return self.group_name.split(RepoGroup.url_sep())[-1]
+
+    @property
+    def full_path(self):
+        return self.group_name
+
+    @property
+    def full_path_splitted(self):
+        return self.group_name.split(RepoGroup.url_sep())
+
+    @property
+    def repositories(self):
+        return Repository.query()\
+                .filter(Repository.group == self)\
+                .order_by(Repository.repo_name)
+
+    @property
+    def repositories_recursive_count(self):
+        cnt = self.repositories.count()
+
+        def children_count(group):
+            cnt = 0
+            for child in group.children:
+                cnt += child.repositories.count()
+                cnt += children_count(child)
+            return cnt
+
+        return cnt + children_count(self)
+
+    def _recursive_objects(self, include_repos=True):
+        all_ = []
+
+        def _get_members(root_gr):
+            if include_repos:
+                for r in root_gr.repositories:
+                    all_.append(r)
+            childs = root_gr.children.all()
+            if childs:
+                for gr in childs:
+                    all_.append(gr)
+                    _get_members(gr)
+
+        _get_members(self)
+        return [self] + all_
+
+    def recursive_groups_and_repos(self):
+        """
+        Recursive return all groups, with repositories in those groups
+        """
+        return self._recursive_objects()
+
+    def recursive_groups(self):
+        """
+        Returns all children groups for this group including children of children
+        """
+        return self._recursive_objects(include_repos=False)
+
+    def get_new_name(self, group_name):
+        """
+        returns new full group name based on parent and new name
+
+        :param group_name:
+        """
+        path_prefix = (self.parent_group.full_path_splitted if
+                       self.parent_group else [])
+        return RepoGroup.url_sep().join(path_prefix + [group_name])
+
+    def permissions(self, with_admins=True, with_owner=True):
+        q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
+        q = q.options(joinedload(UserRepoGroupToPerm.group),
+                      joinedload(UserRepoGroupToPerm.user),
+                      joinedload(UserRepoGroupToPerm.permission),)
+
+        # get owners and admins and permissions. We do a trick of re-writing
+        # objects from sqlalchemy to named-tuples due to sqlalchemy session
+        # has a global reference and changing one object propagates to all
+        # others. This means if admin is also an owner admin_row that change
+        # would propagate to both objects
+        perm_rows = []
+        for _usr in q.all():
+            usr = AttributeDict(_usr.user.get_dict())
+            usr.permission = _usr.permission.permission_name
+            perm_rows.append(usr)
+
+        # filter the perm rows by 'default' first and then sort them by
+        # admin,write,read,none permissions sorted again alphabetically in
+        # each group
+        perm_rows = sorted(perm_rows, key=display_sort)
+
+        _admin_perm = 'group.admin'
+        owner_row = []
+        if with_owner:
+            usr = AttributeDict(self.user.get_dict())
+            usr.owner_row = True
+            usr.permission = _admin_perm
+            owner_row.append(usr)
+
+        super_admin_rows = []
+        if with_admins:
+            for usr in User.get_all_super_admins():
+                # if this admin is also owner, don't double the record
+                if usr.user_id == owner_row[0].user_id:
+                    owner_row[0].admin_row = True
+                else:
+                    usr = AttributeDict(usr.get_dict())
+                    usr.admin_row = True
+                    usr.permission = _admin_perm
+                    super_admin_rows.append(usr)
+
+        return super_admin_rows + owner_row + perm_rows
+
+    def permission_user_groups(self):
+        q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
+        q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
+                      joinedload(UserGroupRepoGroupToPerm.users_group),
+                      joinedload(UserGroupRepoGroupToPerm.permission),)
+
+        perm_rows = []
+        for _user_group in q.all():
+            usr = AttributeDict(_user_group.users_group.get_dict())
+            usr.permission = _user_group.permission.permission_name
+            perm_rows.append(usr)
+
+        return perm_rows
+
+    def get_api_data(self):
+        """
+        Common function for generating api data
+
+        """
+        group = self
+        data = {
+            'group_id': group.group_id,
+            'group_name': group.group_name,
+            'group_description': group.group_description,
+            'parent_group': group.parent_group.group_name if group.parent_group else None,
+            'repositories': [x.repo_name for x in group.repositories],
+            'owner': group.user.username,
+        }
+        return data
+
+
+class Permission(Base, BaseModel):
+    __tablename__ = 'permissions'
+    __table_args__ = (
+        Index('p_perm_name_idx', 'permission_name'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    PERMS = [
+        ('hg.admin', _('RhodeCode Super Administrator')),
+
+        ('repository.none', _('Repository no access')),
+        ('repository.read', _('Repository read access')),
+        ('repository.write', _('Repository write access')),
+        ('repository.admin', _('Repository admin access')),
+
+        ('group.none', _('Repository group no access')),
+        ('group.read', _('Repository group read access')),
+        ('group.write', _('Repository group write access')),
+        ('group.admin', _('Repository group admin access')),
+
+        ('usergroup.none', _('User group no access')),
+        ('usergroup.read', _('User group read access')),
+        ('usergroup.write', _('User group write access')),
+        ('usergroup.admin', _('User group admin access')),
+
+        ('hg.repogroup.create.false', _('Repository Group creation disabled')),
+        ('hg.repogroup.create.true', _('Repository Group creation enabled')),
+
+        ('hg.usergroup.create.false', _('User Group creation disabled')),
+        ('hg.usergroup.create.true', _('User Group creation enabled')),
+
+        ('hg.create.none', _('Repository creation disabled')),
+        ('hg.create.repository', _('Repository creation enabled')),
+        ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
+        ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
+
+        ('hg.fork.none', _('Repository forking disabled')),
+        ('hg.fork.repository', _('Repository forking enabled')),
+
+        ('hg.register.none', _('Registration disabled')),
+        ('hg.register.manual_activate', _('User Registration with manual account activation')),
+        ('hg.register.auto_activate', _('User Registration with automatic account activation')),
+
+        ('hg.extern_activate.manual', _('Manual activation of external account')),
+        ('hg.extern_activate.auto', _('Automatic activation of external account')),
+
+        ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
+        ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
+    ]
+
+    # definition of system default permissions for DEFAULT user
+    DEFAULT_USER_PERMISSIONS = [
+        'repository.read',
+        'group.read',
+        'usergroup.read',
+        'hg.create.repository',
+        'hg.repogroup.create.false',
+        'hg.usergroup.create.false',
+        'hg.create.write_on_repogroup.true',
+        'hg.fork.repository',
+        'hg.register.manual_activate',
+        'hg.extern_activate.auto',
+        'hg.inherit_default_perms.true',
+    ]
+
+    # defines which permissions are more important higher the more important
+    # Weight defines which permissions are more important.
+    # The higher number the more important.
+    PERM_WEIGHTS = {
+        'repository.none': 0,
+        'repository.read': 1,
+        'repository.write': 3,
+        'repository.admin': 4,
+
+        'group.none': 0,
+        'group.read': 1,
+        'group.write': 3,
+        'group.admin': 4,
+
+        'usergroup.none': 0,
+        'usergroup.read': 1,
+        'usergroup.write': 3,
+        'usergroup.admin': 4,
+
+        'hg.repogroup.create.false': 0,
+        'hg.repogroup.create.true': 1,
+
+        'hg.usergroup.create.false': 0,
+        'hg.usergroup.create.true': 1,
+
+        'hg.fork.none': 0,
+        'hg.fork.repository': 1,
+        'hg.create.none': 0,
+        'hg.create.repository': 1
+    }
+
+    permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
+    permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
+
+    def __unicode__(self):
+        return u"<%s('%s:%s')>" % (
+            self.__class__.__name__, self.permission_id, self.permission_name
+        )
+
+    @classmethod
+    def get_by_key(cls, key):
+        return cls.query().filter(cls.permission_name == key).scalar()
+
+    @classmethod
+    def get_default_repo_perms(cls, user_id, repo_id=None):
+        q = Session().query(UserRepoToPerm, Repository, Permission)\
+            .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
+            .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
+            .filter(UserRepoToPerm.user_id == user_id)
+        if repo_id:
+            q = q.filter(UserRepoToPerm.repository_id == repo_id)
+        return q.all()
+
+    @classmethod
+    def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
+        q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
+            .join(
+                Permission,
+                UserGroupRepoToPerm.permission_id == Permission.permission_id)\
+            .join(
+                Repository,
+                UserGroupRepoToPerm.repository_id == Repository.repo_id)\
+            .join(
+                UserGroup,
+                UserGroupRepoToPerm.users_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupRepoToPerm.users_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if repo_id:
+            q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
+        return q.all()
+
+    @classmethod
+    def get_default_group_perms(cls, user_id, repo_group_id=None):
+        q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
+            .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
+            .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
+            .filter(UserRepoGroupToPerm.user_id == user_id)
+        if repo_group_id:
+            q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_group_perms_from_user_group(
+            cls, user_id, repo_group_id=None):
+        q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
+            .join(
+                Permission,
+                UserGroupRepoGroupToPerm.permission_id ==
+                Permission.permission_id)\
+            .join(
+                RepoGroup,
+                UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
+            .join(
+                UserGroup,
+                UserGroupRepoGroupToPerm.users_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupRepoGroupToPerm.users_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if repo_group_id:
+            q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_user_group_perms(cls, user_id, user_group_id=None):
+        q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
+            .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
+            .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
+            .filter(UserUserGroupToPerm.user_id == user_id)
+        if user_group_id:
+            q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
+        return q.all()
+
+    @classmethod
+    def get_default_user_group_perms_from_user_group(
+            cls, user_id, user_group_id=None):
+        TargetUserGroup = aliased(UserGroup, name='target_user_group')
+        q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
+            .join(
+                Permission,
+                UserGroupUserGroupToPerm.permission_id ==
+                Permission.permission_id)\
+            .join(
+                TargetUserGroup,
+                UserGroupUserGroupToPerm.target_user_group_id ==
+                TargetUserGroup.users_group_id)\
+            .join(
+                UserGroup,
+                UserGroupUserGroupToPerm.user_group_id ==
+                UserGroup.users_group_id)\
+            .join(
+                UserGroupMember,
+                UserGroupUserGroupToPerm.user_group_id ==
+                UserGroupMember.users_group_id)\
+            .filter(
+                UserGroupMember.user_id == user_id,
+                UserGroup.users_group_active == true())
+        if user_group_id:
+            q = q.filter(
+                UserGroupUserGroupToPerm.user_group_id == user_group_id)
+
+        return q.all()
+
+
+class UserRepoToPerm(Base, BaseModel):
+    __tablename__ = 'repo_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'repository_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    repository = relationship('Repository')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, repository, permission):
+        n = cls()
+        n.user = user
+        n.repository = repository
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.repository)
+
+
+class UserUserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_user_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    user_group = relationship('UserGroup')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, user_group, permission):
+        n = cls()
+        n.user = user
+        n.user_group = user_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.user_group)
+
+
+class UserToPerm(Base, BaseModel):
+    __tablename__ = 'user_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    permission = relationship('Permission', lazy='joined')
+
+    def __unicode__(self):
+        return u'<%s => %s >' % (self.user, self.permission)
+
+
+class UserGroupRepoToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_repo_to_perm'
+    __table_args__ = (
+        UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+    repository = relationship('Repository')
+
+    @classmethod
+    def create(cls, users_group, repository, permission):
+        n = cls()
+        n.users_group = users_group
+        n.repository = repository
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
+
+
+class UserGroupUserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_group_user_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
+        CheckConstraint('target_user_group_id != user_group_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+
+    target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
+    user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, target_user_group, user_group, permission):
+        n = cls()
+        n.target_user_group = target_user_group
+        n.user_group = user_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
+
+
+class UserGroupToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('users_group_id', 'permission_id',),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+
+
+class UserRepoGroupToPerm(Base, BaseModel):
+    __tablename__ = 'user_repo_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'group_id', 'permission_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    group = relationship('RepoGroup')
+    permission = relationship('Permission')
+
+    @classmethod
+    def create(cls, user, repository_group, permission):
+        n = cls()
+        n.user = user
+        n.group = repository_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+
+class UserGroupRepoGroupToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_repo_group_to_perm'
+    __table_args__ = (
+        UniqueConstraint('users_group_id', 'group_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UserGroup')
+    permission = relationship('Permission')
+    group = relationship('RepoGroup')
+
+    @classmethod
+    def create(cls, user_group, repository_group, permission):
+        n = cls()
+        n.users_group = user_group
+        n.group = repository_group
+        n.permission = permission
+        Session().add(n)
+        return n
+
+    def __unicode__(self):
+        return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
+
+
+class Statistics(Base, BaseModel):
+    __tablename__ = 'statistics'
+    __table_args__ = (
+         UniqueConstraint('repository_id'),
+         {'extend_existing': True, 'mysql_engine': 'InnoDB',
+          'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
+    stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
+    commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
+    commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
+    languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
+
+    repository = relationship('Repository', single_parent=True)
+
+
+class UserFollowing(Base, BaseModel):
+    __tablename__ = 'user_followings'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'follows_repository_id'),
+        UniqueConstraint('user_id', 'follows_user_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
+    follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
+
+    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
+
+    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
+    follows_repository = relationship('Repository', order_by='Repository.repo_name')
+
+    @classmethod
+    def get_repo_followers(cls, repo_id):
+        return cls.query().filter(cls.follows_repo_id == repo_id)
+
+
+class CacheKey(Base, BaseModel):
+    __tablename__ = 'cache_invalidation'
+    __table_args__ = (
+        UniqueConstraint('cache_key'),
+        Index('key_idx', 'cache_key'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    CACHE_TYPE_ATOM = 'ATOM'
+    CACHE_TYPE_RSS = 'RSS'
+    CACHE_TYPE_README = 'README'
+
+    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
+    cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
+    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
+
+    def __init__(self, cache_key, cache_args=''):
+        self.cache_key = cache_key
+        self.cache_args = cache_args
+        self.cache_active = False
+
+    def __unicode__(self):
+        return u"<%s('%s:%s[%s]')>" % (
+            self.__class__.__name__,
+            self.cache_id, self.cache_key, self.cache_active)
+
+    def _cache_key_partition(self):
+        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
+        return prefix, repo_name, suffix
+
+    def get_prefix(self):
+        """
+        Try to extract prefix from existing cache key. The key could consist
+        of prefix, repo_name, suffix
+        """
+        # this returns prefix, repo_name, suffix
+        return self._cache_key_partition()[0]
+
+    def get_suffix(self):
+        """
+        get suffix that might have been used in _get_cache_key to
+        generate self.cache_key. Only used for informational purposes
+        in repo_edit.html.
+        """
+        # prefix, repo_name, suffix
+        return self._cache_key_partition()[2]
+
+    @classmethod
+    def delete_all_cache(cls):
+        """
+        Delete all cache keys from database.
+        Should only be run when all instances are down and all entries
+        thus stale.
+        """
+        cls.query().delete()
+        Session().commit()
+
+    @classmethod
+    def get_cache_key(cls, repo_name, cache_type):
+        """
+
+        Generate a cache key for this process of RhodeCode instance.
+        Prefix most likely will be process id or maybe explicitly set
+        instance_id from .ini file.
+        """
+        import rhodecode
+        prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
+
+        repo_as_unicode = safe_unicode(repo_name)
+        key = u'{}_{}'.format(repo_as_unicode, cache_type) \
+            if cache_type else repo_as_unicode
+
+        return u'{}{}'.format(prefix, key)
+
+    @classmethod
+    def set_invalidate(cls, repo_name, delete=False):
+        """
+        Mark all caches of a repo as invalid in the database.
+        """
+
+        try:
+            qry = Session().query(cls).filter(cls.cache_args == repo_name)
+            if delete:
+                log.debug('cache objects deleted for repo %s',
+                          safe_str(repo_name))
+                qry.delete()
+            else:
+                log.debug('cache objects marked as invalid for repo %s',
+                          safe_str(repo_name))
+                qry.update({"cache_active": False})
+
+            Session().commit()
+        except Exception:
+            log.exception(
+                'Cache key invalidation failed for repository %s',
+                safe_str(repo_name))
+            Session().rollback()
+
+    @classmethod
+    def get_active_cache(cls, cache_key):
+        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
+        if inv_obj:
+            return inv_obj
+        return None
+
+    @classmethod
+    def repo_context_cache(cls, compute_func, repo_name, cache_type,
+                           thread_scoped=False):
+        """
+        @cache_region('long_term')
+        def _heavy_calculation(cache_key):
+            return 'result'
+
+        cache_context = CacheKey.repo_context_cache(
+            _heavy_calculation, repo_name, cache_type)
+
+        with cache_context as context:
+            context.invalidate()
+            computed = context.compute()
+
+        assert computed == 'result'
+        """
+        from rhodecode.lib import caches
+        return caches.InvalidationContext(
+            compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
+
+
+class ChangesetComment(Base, BaseModel):
+    __tablename__ = 'changeset_comments'
+    __table_args__ = (
+        Index('cc_revision_idx', 'revision'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    COMMENT_OUTDATED = u'comment_outdated'
+
+    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
+    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
+    revision = Column('revision', String(40), nullable=True)
+    pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
+    pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
+    line_no = Column('line_no', Unicode(10), nullable=True)
+    hl_lines = Column('hl_lines', Unicode(512), nullable=True)
+    f_path = Column('f_path', Unicode(1000), nullable=True)
+    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
+    text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    renderer = Column('renderer', Unicode(64), nullable=True)
+    display_state = Column('display_state',  Unicode(128), nullable=True)
+
+    author = relationship('User', lazy='joined')
+    repo = relationship('Repository')
+    status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
+    pull_request = relationship('PullRequest', lazy='joined')
+    pull_request_version = relationship('PullRequestVersion')
+
+    @classmethod
+    def get_users(cls, revision=None, pull_request_id=None):
+        """
+        Returns user associated with this ChangesetComment. ie those
+        who actually commented
+
+        :param cls:
+        :param revision:
+        """
+        q = Session().query(User)\
+                .join(ChangesetComment.author)
+        if revision:
+            q = q.filter(cls.revision == revision)
+        elif pull_request_id:
+            q = q.filter(cls.pull_request_id == pull_request_id)
+        return q.all()
+
+    def render(self, mentions=False):
+        from rhodecode.lib import helpers as h
+        return h.render(self.text, renderer=self.renderer, mentions=mentions)
+
+    def __repr__(self):
+        if self.comment_id:
+            return '<DB:ChangesetComment #%s>' % self.comment_id
+        else:
+            return '<DB:ChangesetComment at %#x>' % id(self)
+
+
+class ChangesetStatus(Base, BaseModel):
+    __tablename__ = 'changeset_statuses'
+    __table_args__ = (
+        Index('cs_revision_idx', 'revision'),
+        Index('cs_version_idx', 'version'),
+        UniqueConstraint('repo_id', 'revision', 'version'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
+    STATUS_APPROVED = 'approved'
+    STATUS_REJECTED = 'rejected'
+    STATUS_UNDER_REVIEW = 'under_review'
+
+    STATUSES = [
+        (STATUS_NOT_REVIEWED, _("Not Reviewed")),  # (no icon) and default
+        (STATUS_APPROVED, _("Approved")),
+        (STATUS_REJECTED, _("Rejected")),
+        (STATUS_UNDER_REVIEW, _("Under Review")),
+    ]
+
+    changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
+    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
+    revision = Column('revision', String(40), nullable=False)
+    status = Column('status', String(128), nullable=False, default=DEFAULT)
+    changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
+    modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
+    version = Column('version', Integer(), nullable=False, default=0)
+    pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
+
+    author = relationship('User', lazy='joined')
+    repo = relationship('Repository')
+    comment = relationship('ChangesetComment', lazy='joined')
+    pull_request = relationship('PullRequest', lazy='joined')
+
+    def __unicode__(self):
+        return u"<%s('%s[%s]:%s')>" % (
+            self.__class__.__name__,
+            self.status, self.version, self.author
+        )
+
+    @classmethod
+    def get_status_lbl(cls, value):
+        return dict(cls.STATUSES).get(value)
+
+    @property
+    def status_lbl(self):
+        return ChangesetStatus.get_status_lbl(self.status)
+
+
+class _PullRequestBase(BaseModel):
+    """
+    Common attributes of pull request and version entries.
+    """
+
+    # .status values
+    STATUS_NEW = u'new'
+    STATUS_OPEN = u'open'
+    STATUS_CLOSED = u'closed'
+
+    title = Column('title', Unicode(255), nullable=True)
+    description = Column(
+        'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
+        nullable=True)
+    # new/open/closed status of pull request (not approve/reject/etc)
+    status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
+    created_on = Column(
+        'created_on', DateTime(timezone=False), nullable=False,
+        default=datetime.datetime.now)
+    updated_on = Column(
+        'updated_on', DateTime(timezone=False), nullable=False,
+        default=datetime.datetime.now)
+
+    @declared_attr
+    def user_id(cls):
+        return Column(
+            "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
+            unique=None)
+
+    # 500 revisions max
+    _revisions = Column(
+        'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
+
+    @declared_attr
+    def source_repo_id(cls):
+        # TODO: dan: rename column to source_repo_id
+        return Column(
+            'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
+            nullable=False)
+
+    source_ref = Column('org_ref', Unicode(255), nullable=False)
+
+    @declared_attr
+    def target_repo_id(cls):
+        # TODO: dan: rename column to target_repo_id
+        return Column(
+            'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
+            nullable=False)
+
+    target_ref = Column('other_ref', Unicode(255), nullable=False)
+
+    # TODO: dan: rename column to last_merge_source_rev
+    _last_merge_source_rev = Column(
+        'last_merge_org_rev', String(40), nullable=True)
+    # TODO: dan: rename column to last_merge_target_rev
+    _last_merge_target_rev = Column(
+        'last_merge_other_rev', String(40), nullable=True)
+    _last_merge_status = Column('merge_status', Integer(), nullable=True)
+    merge_rev = Column('merge_rev', String(40), nullable=True)
+
+    @hybrid_property
+    def revisions(self):
+        return self._revisions.split(':') if self._revisions else []
+
+    @revisions.setter
+    def revisions(self, val):
+        self._revisions = ':'.join(val)
+
+    @declared_attr
+    def author(cls):
+        return relationship('User', lazy='joined')
+
+    @declared_attr
+    def source_repo(cls):
+        return relationship(
+            'Repository',
+            primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
+
+    @property
+    def source_ref_parts(self):
+        refs = self.source_ref.split(':')
+        return Reference(refs[0], refs[1], refs[2])
+
+    @declared_attr
+    def target_repo(cls):
+        return relationship(
+            'Repository',
+            primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
+
+    @property
+    def target_ref_parts(self):
+        refs = self.target_ref.split(':')
+        return Reference(refs[0], refs[1], refs[2])
+
+
+class PullRequest(Base, _PullRequestBase):
+    __tablename__ = 'pull_requests'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    pull_request_id = Column(
+        'pull_request_id', Integer(), nullable=False, primary_key=True)
+
+    def __repr__(self):
+        if self.pull_request_id:
+            return '<DB:PullRequest #%s>' % self.pull_request_id
+        else:
+            return '<DB:PullRequest at %#x>' % id(self)
+
+    reviewers = relationship('PullRequestReviewers',
+                             cascade="all, delete, delete-orphan")
+    statuses = relationship('ChangesetStatus')
+    comments = relationship('ChangesetComment',
+                            cascade="all, delete, delete-orphan")
+    versions = relationship('PullRequestVersion',
+                            cascade="all, delete, delete-orphan")
+
+    def is_closed(self):
+        return self.status == self.STATUS_CLOSED
+
+    def get_api_data(self):
+        from rhodecode.model.pull_request import PullRequestModel
+        pull_request = self
+        merge_status = PullRequestModel().merge_status(pull_request)
+        data = {
+            'pull_request_id': pull_request.pull_request_id,
+            'url': url('pullrequest_show', repo_name=self.target_repo.repo_name,
+                                       pull_request_id=self.pull_request_id,
+                                       qualified=True),
+            'title': pull_request.title,
+            'description': pull_request.description,
+            'status': pull_request.status,
+            'created_on': pull_request.created_on,
+            'updated_on': pull_request.updated_on,
+            'commit_ids': pull_request.revisions,
+            'review_status': pull_request.calculated_review_status(),
+            'mergeable': {
+                'status': merge_status[0],
+                'message': unicode(merge_status[1]),
+            },
+            'source': {
+                'clone_url': pull_request.source_repo.clone_url(),
+                'repository': pull_request.source_repo.repo_name,
+                'reference': {
+                    'name': pull_request.source_ref_parts.name,
+                    'type': pull_request.source_ref_parts.type,
+                    'commit_id': pull_request.source_ref_parts.commit_id,
+                },
+            },
+            'target': {
+                'clone_url': pull_request.target_repo.clone_url(),
+                'repository': pull_request.target_repo.repo_name,
+                'reference': {
+                    'name': pull_request.target_ref_parts.name,
+                    'type': pull_request.target_ref_parts.type,
+                    'commit_id': pull_request.target_ref_parts.commit_id,
+                },
+            },
+            'author': pull_request.author.get_api_data(include_secrets=False,
+                                                       details='basic'),
+            'reviewers': [
+                {
+                    'user': reviewer.get_api_data(include_secrets=False,
+                                                  details='basic'),
+                    'reasons': reasons,
+                    'review_status': st[0][1].status if st else 'not_reviewed',
+                }
+                for reviewer, reasons, st in pull_request.reviewers_statuses()
+            ]
+        }
+
+        return data
+
+    def __json__(self):
+        return {
+            'revisions': self.revisions,
+        }
+
+    def calculated_review_status(self):
+        # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
+        # because it's tricky on how to use ChangesetStatusModel from there
+        warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
+        from rhodecode.model.changeset_status import ChangesetStatusModel
+        return ChangesetStatusModel().calculated_review_status(self)
+
+    def reviewers_statuses(self):
+        warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
+        from rhodecode.model.changeset_status import ChangesetStatusModel
+        return ChangesetStatusModel().reviewers_statuses(self)
+
+
+class PullRequestVersion(Base, _PullRequestBase):
+    __tablename__ = 'pull_request_versions'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    pull_request_version_id = Column(
+        'pull_request_version_id', Integer(), nullable=False, primary_key=True)
+    pull_request_id = Column(
+        'pull_request_id', Integer(),
+        ForeignKey('pull_requests.pull_request_id'), nullable=False)
+    pull_request = relationship('PullRequest')
+
+    def __repr__(self):
+        if self.pull_request_version_id:
+            return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
+        else:
+            return '<DB:PullRequestVersion at %#x>' % id(self)
+
+
+class PullRequestReviewers(Base, BaseModel):
+    __tablename__ = 'pull_request_reviewers'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    def __init__(self, user=None, pull_request=None, reasons=None):
+        self.user = user
+        self.pull_request = pull_request
+        self.reasons = reasons or []
+
+    @hybrid_property
+    def reasons(self):
+        if not self._reasons:
+            return []
+        return self._reasons
+
+    @reasons.setter
+    def reasons(self, val):
+        val = val or []
+        if any(not isinstance(x, basestring) for x in val):
+            raise Exception('invalid reasons type, must be list of strings')
+        self._reasons = val
+
+    pull_requests_reviewers_id = Column(
+        'pull_requests_reviewers_id', Integer(), nullable=False,
+        primary_key=True)
+    pull_request_id = Column(
+        "pull_request_id", Integer(),
+        ForeignKey('pull_requests.pull_request_id'), nullable=False)
+    user_id = Column(
+        "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
+    _reasons = Column(
+        'reason', MutationList.as_mutable(
+            JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
+
+    user = relationship('User')
+    pull_request = relationship('PullRequest')
+
+
+class Notification(Base, BaseModel):
+    __tablename__ = 'notifications'
+    __table_args__ = (
+        Index('notification_type_idx', 'type'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+
+    TYPE_CHANGESET_COMMENT = u'cs_comment'
+    TYPE_MESSAGE = u'message'
+    TYPE_MENTION = u'mention'
+    TYPE_REGISTRATION = u'registration'
+    TYPE_PULL_REQUEST = u'pull_request'
+    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
+
+    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
+    subject = Column('subject', Unicode(512), nullable=True)
+    body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
+    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    type_ = Column('type', Unicode(255))
+
+    created_by_user = relationship('User')
+    notifications_to_users = relationship('UserNotification', lazy='joined',
+                                          cascade="all, delete, delete-orphan")
+
+    @property
+    def recipients(self):
+        return [x.user for x in UserNotification.query()\
+                .filter(UserNotification.notification == self)\
+                .order_by(UserNotification.user_id.asc()).all()]
+
+    @classmethod
+    def create(cls, created_by, subject, body, recipients, type_=None):
+        if type_ is None:
+            type_ = Notification.TYPE_MESSAGE
+
+        notification = cls()
+        notification.created_by_user = created_by
+        notification.subject = subject
+        notification.body = body
+        notification.type_ = type_
+        notification.created_on = datetime.datetime.now()
+
+        for u in recipients:
+            assoc = UserNotification()
+            assoc.notification = notification
+
+            # if created_by is inside recipients mark his notification
+            # as read
+            if u.user_id == created_by.user_id:
+                assoc.read = True
+
+            u.notifications.append(assoc)
+        Session().add(notification)
+
+        return notification
+
+    @property
+    def description(self):
+        from rhodecode.model.notification import NotificationModel
+        return NotificationModel().make_description(self)
+
+
+class UserNotification(Base, BaseModel):
+    __tablename__ = 'user_to_notification'
+    __table_args__ = (
+        UniqueConstraint('user_id', 'notification_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
+    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
+    read = Column('read', Boolean, default=False)
+    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
+
+    user = relationship('User', lazy="joined")
+    notification = relationship('Notification', lazy="joined",
+                                order_by=lambda: Notification.created_on.desc(),)
+
+    def mark_as_read(self):
+        self.read = True
+        Session().add(self)
+
+
+class Gist(Base, BaseModel):
+    __tablename__ = 'gists'
+    __table_args__ = (
+        Index('g_gist_access_id_idx', 'gist_access_id'),
+        Index('g_created_on_idx', 'created_on'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+    GIST_PUBLIC = u'public'
+    GIST_PRIVATE = u'private'
+    DEFAULT_FILENAME = u'gistfile1.txt'
+
+    ACL_LEVEL_PUBLIC = u'acl_public'
+    ACL_LEVEL_PRIVATE = u'acl_private'
+
+    gist_id = Column('gist_id', Integer(), primary_key=True)
+    gist_access_id = Column('gist_access_id', Unicode(250))
+    gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
+    gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
+    gist_expires = Column('gist_expires', Float(53), nullable=False)
+    gist_type = Column('gist_type', Unicode(128), nullable=False)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    acl_level = Column('acl_level', Unicode(128), nullable=True)
+
+    owner = relationship('User')
+
+    def __repr__(self):
+        return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
+
+    @classmethod
+    def get_or_404(cls, id_):
+        res = cls.query().filter(cls.gist_access_id == id_).scalar()
+        if not res:
+            raise HTTPNotFound
+        return res
+
+    @classmethod
+    def get_by_access_id(cls, gist_access_id):
+        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
+
+    def gist_url(self):
+        import rhodecode
+        alias_url = rhodecode.CONFIG.get('gist_alias_url')
+        if alias_url:
+            return alias_url.replace('{gistid}', self.gist_access_id)
+
+        return url('gist', gist_id=self.gist_access_id, qualified=True)
+
+    @classmethod
+    def base_path(cls):
+        """
+        Returns base path when all gists are stored
+
+        :param cls:
+        """
+        from rhodecode.model.gist import GIST_STORE_LOC
+        q = Session().query(RhodeCodeUi)\
+            .filter(RhodeCodeUi.ui_key == URL_SEP)
+        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return os.path.join(q.one().ui_value, GIST_STORE_LOC)
+
+    def get_api_data(self):
+        """
+        Common function for generating gist related data for API
+        """
+        gist = self
+        data = {
+            'gist_id': gist.gist_id,
+            'type': gist.gist_type,
+            'access_id': gist.gist_access_id,
+            'description': gist.gist_description,
+            'url': gist.gist_url(),
+            'expires': gist.gist_expires,
+            'created_on': gist.created_on,
+            'modified_at': gist.modified_at,
+            'content': None,
+            'acl_level': gist.acl_level,
+        }
+        return data
+
+    def __json__(self):
+        data = dict(
+        )
+        data.update(self.get_api_data())
+        return data
+    # SCM functions
+
+    def scm_instance(self, **kwargs):
+        full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
+        return get_vcs_instance(
+            repo_path=safe_str(full_repo_path), create=False)
+
+
+class DbMigrateVersion(Base, BaseModel):
+    __tablename__ = 'db_migrate_version'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
+    repository_id = Column('repository_id', String(250), primary_key=True)
+    repository_path = Column('repository_path', Text)
+    version = Column('version', Integer)
+
+
+class ExternalIdentity(Base, BaseModel):
+    __tablename__ = 'external_identities'
+    __table_args__ = (
+        Index('local_user_id_idx', 'local_user_id'),
+        Index('external_id_idx', 'external_id'),
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8'})
+
+    external_id = Column('external_id', Unicode(255), default=u'',
+                         primary_key=True)
+    external_username = Column('external_username', Unicode(1024), default=u'')
+    local_user_id = Column('local_user_id', Integer(),
+                           ForeignKey('users.user_id'), primary_key=True)
+    provider_name = Column('provider_name', Unicode(255), default=u'',
+                           primary_key=True)
+    access_token = Column('access_token', String(1024), default=u'')
+    alt_token = Column('alt_token', String(1024), default=u'')
+    token_secret = Column('token_secret', String(1024), default=u'')
+
+    @classmethod
+    def by_external_id_and_provider(cls, external_id, provider_name,
+                                    local_user_id=None):
+        """
+        Returns ExternalIdentity instance based on search params
+
+        :param external_id:
+        :param provider_name:
+        :return: ExternalIdentity
+        """
+        query = cls.query()
+        query = query.filter(cls.external_id == external_id)
+        query = query.filter(cls.provider_name == provider_name)
+        if local_user_id:
+            query = query.filter(cls.local_user_id == local_user_id)
+        return query.first()
+
+    @classmethod
+    def user_by_external_id_and_provider(cls, external_id, provider_name):
+        """
+        Returns User instance based on search params
+
+        :param external_id:
+        :param provider_name:
+        :return: User
+        """
+        query = User.query()
+        query = query.filter(cls.external_id == external_id)
+        query = query.filter(cls.provider_name == provider_name)
+        query = query.filter(User.user_id == cls.local_user_id)
+        return query.first()
+
+    @classmethod
+    def by_local_user_id(cls, local_user_id):
+        """
+        Returns all tokens for user
+
+        :param local_user_id:
+        :return: ExternalIdentity
+        """
+        query = cls.query()
+        query = query.filter(cls.local_user_id == local_user_id)
+        return query
+
+
+class Integration(Base, BaseModel):
+    __tablename__ = 'integrations'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
+    )
+
+    integration_id = Column('integration_id', Integer(), primary_key=True)
+    integration_type = Column('integration_type', String(255))
+    enabled = Column('enabled', Boolean(), nullable=False)
+    name = Column('name', String(255), nullable=False)
+    child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
+        default=False)
+
+    settings = Column(
+        'settings_json', MutationObj.as_mutable(
+            JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
+    repo_id = Column(
+        'repo_id', Integer(), ForeignKey('repositories.repo_id'),
+        nullable=True, unique=None, default=None)
+    repo = relationship('Repository', lazy='joined')
+
+    repo_group_id = Column(
+        'repo_group_id', Integer(), ForeignKey('groups.group_id'),
+        nullable=True, unique=None, default=None)
+    repo_group = relationship('RepoGroup', lazy='joined')
+
+    @property
+    def scope(self):
+        if self.repo:
+            return repr(self.repo)
+        if self.repo_group:
+            if self.child_repos_only:
+                return repr(self.repo_group) + ' (child repos only)'
+            else:
+                return repr(self.repo_group) + ' (recursive)'
+        if self.child_repos_only:
+            return 'root_repos'
+        return 'global'
+
+    def __repr__(self):
+        return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
+
+
+class RepoReviewRuleUser(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_user_id = Column(
+        'repo_review_rule_user_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
+        nullable=False)
+    user = relationship('User')
+
+
+class RepoReviewRuleUserGroup(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users_groups'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_users_group_id = Column(
+        'repo_review_rule_users_group_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    users_group_id = Column("users_group_id", Integer(),
+        ForeignKey('users_groups.users_group_id'), nullable=False)
+    users_group = relationship('UserGroup')
+
+
+class RepoReviewRule(Base, BaseModel):
+    __tablename__ = 'repo_review_rules'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+
+    repo_review_rule_id = Column(
+        'repo_review_rule_id', Integer(), primary_key=True)
+    repo_id = Column(
+        "repo_id", Integer(), ForeignKey('repositories.repo_id'))
+    repo = relationship('Repository', backref='review_rules')
+
+    _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+    _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+
+    use_authors_for_review = Column("use_authors_for_review", Boolean(),
+        nullable=False, default=False)
+    rule_users = relationship('RepoReviewRuleUser')
+    rule_user_groups = relationship('RepoReviewRuleUserGroup')
+
+    @hybrid_property
+    def branch_pattern(self):
+        return self._branch_pattern or '*'
+
+    def _validate_glob(self, value):
+        re.compile('^' + glob2re(value) + '$')
+
+    @branch_pattern.setter
+    def branch_pattern(self, value):
+        self._validate_glob(value)
+        self._branch_pattern = value or '*'
+
+    @hybrid_property
+    def file_pattern(self):
+        return self._file_pattern or '*'
+
+    @file_pattern.setter
+    def file_pattern(self, value):
+        self._validate_glob(value)
+        self._file_pattern = value or '*'
+
+    def matches(self, branch, files_changed):
+        """
+        Check if this review rule matches a branch/files in a pull request
+
+        :param branch: branch name for the commit
+        :param files_changed: list of file paths changed in the pull request
+        """
+
+        branch = branch or ''
+        files_changed = files_changed or []
+
+        branch_matches = True
+        if branch:
+            branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
+            branch_matches = bool(branch_regex.search(branch))
+
+        files_matches = True
+        if self.file_pattern != '*':
+            files_matches = False
+            file_regex = re.compile(glob2re(self.file_pattern))
+            for filename in files_changed:
+                if file_regex.search(filename):
+                    files_matches = True
+                    break
+
+        return branch_matches and files_matches
+
+    @property
+    def review_users(self):
+        """ Returns the users which this rule applies to """
+
+        users = set()
+        users |= set([
+            rule_user.user for rule_user in self.rule_users
+            if rule_user.user.active])
+        users |= set(
+            member.user
+            for rule_user_group in self.rule_user_groups
+            for member in rule_user_group.users_group.members
+            if member.user.active
+        )
+        return users
+
+    def __repr__(self):
+        return '<RepoReviewerRule(id=%r, repo=%r)>' % (
+            self.repo_review_rule_id, self.repo)

rhodecode/lib/dbmigrate/versions/059_version_4_4_0.py

@@ -0,0 +1,35 b''
+import logging
+import datetime
+
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper, joinedload
+from sqlalchemy.orm.session import Session
+from sqlalchemy.ext.declarative import declarative_base
+
+from rhodecode.lib.dbmigrate.migrate import *
+from rhodecode.lib.dbmigrate.migrate.changeset import *
+from rhodecode.lib.utils2 import str2bool
+
+from rhodecode.model.meta import Base
+from rhodecode.model import meta
+from rhodecode.lib.dbmigrate.versions import _reset_base, notify
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_4_0_2
+
+    db_4_4_0_2.RepoReviewRule.__table__.create()
+    db_4_4_0_2.RepoReviewRuleUser.__table__.create()
+    db_4_4_0_2.RepoReviewRuleUserGroup.__table__.create()
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/dbmigrate/versions/060_version_4_5_0.py

@@ -0,0 +1,34 b''
+import logging
+import datetime
+
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper, joinedload
+from sqlalchemy.orm.session import Session
+from sqlalchemy.ext.declarative import declarative_base
+
+from rhodecode.lib.dbmigrate.migrate import *
+from rhodecode.lib.dbmigrate.migrate.changeset import *
+from rhodecode.lib.utils2 import str2bool
+
+from rhodecode.model.meta import Base
+from rhodecode.model import meta
+from rhodecode.lib.dbmigrate.versions import _reset_base, notify
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_5_0_0
+
+    db_4_5_0_0.PullRequestReviewers.reasons.create(
+        table=db_4_5_0_0.PullRequestReviewers.__table__)
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/dbmigrate/versions/061_version_4_5_0.py

@@ -0,0 +1,42 b''
+import logging
+import datetime
+
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper, joinedload
+from sqlalchemy.orm.session import Session
+from sqlalchemy.ext.declarative import declarative_base
+
+from rhodecode.lib.dbmigrate.migrate import *
+from rhodecode.lib.dbmigrate.migrate.changeset import *
+from rhodecode.lib.utils2 import str2bool
+
+from rhodecode.model.meta import Base
+from rhodecode.model import meta
+from rhodecode.lib.dbmigrate.versions import _reset_base, notify
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_5_0_0
+
+    fixups(db_4_5_0_0, meta.Session)
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+def fixups(models, _SESSION):
+    # ** create default permissions ** #
+    from rhodecode.model.permission import PermissionModel
+    PermissionModel(_SESSION()).create_permissions()
+
+    res = PermissionModel(_SESSION()).create_default_user_permissions(
+        models.User.DEFAULT_USER)
+    _SESSION().commit()

rhodecode/lib/dbmigrate/versions/062_version_4_5_0.py

@@ -0,0 +1,31 b''
+import logging
+
+from sqlalchemy import Column, MetaData, Unicode
+
+from rhodecode.lib.dbmigrate.versions import _reset_base
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_5_0_0 as db
+
+    # Add shadow merge ref column to pull request table.
+    pr_table = db.PullRequest.__table__
+    pr_col = Column('shadow_merge_ref', Unicode(255), nullable=True)
+    pr_col.create(table=pr_table)
+
+    # Add shadow merge ref column to pull request version table.
+    pr_version_table = db.PullRequestVersion.__table__
+    pr_version_col = Column('shadow_merge_ref', Unicode(255), nullable=True)
+    pr_version_col.create(table=pr_version_table)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/dbmigrate/versions/063_version_4_5_0.py

@@ -0,0 +1,27 b''
+import logging
+
+from sqlalchemy import Column, MetaData, Boolean
+
+from rhodecode.lib.dbmigrate.versions import _reset_base
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_5_0_0 as db
+
+    # Add personal  column to RepoGroup table.
+    rg_table = db.RepoGroup.__table__
+    rg_col = Column(
+        'personal', Boolean(), nullable=True, unique=None, default=None)
+    rg_col.create(table=rg_table)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/diff_match_patch.py

@@ -0,0 +1,1919 b''
+#!/usr/bin/python2.4
+
+from __future__ import division
+
+"""Diff Match and Patch
+
+Copyright 2006 Google Inc.
+http://code.google.com/p/google-diff-match-patch/
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""Functions for diff, match and patch.
+
+Computes the difference between two texts to create a patch.
+Applies the patch onto another text, allowing for errors.
+"""
+
+__author__ = '[e-mail] (Neil Fraser)'
+
+import math
+import re
+import sys
+import time
+import urllib
+
+class diff_match_patch:
+  """Class containing the diff, match and patch methods.
+
+  Also contains the behaviour settings.
+  """
+
+  def __init__(self):
+    """Inits a diff_match_patch object with default settings.
+    Redefine these in your program to override the defaults.
+    """
+
+    # Number of seconds to map a diff before giving up (0 for infinity).
+    self.Diff_Timeout = 1.0
+    # Cost of an empty edit operation in terms of edit characters.
+    self.Diff_EditCost = 4
+    # At what point is no match declared (0.0 = perfection, 1.0 = very loose).
+    self.Match_Threshold = 0.5
+    # How far to search for a match (0 = exact location, 1000+ = broad match).
+    # A match this many characters away from the expected location will add
+    # 1.0 to the score (0.0 is a perfect match).
+    self.Match_Distance = 1000
+    # When deleting a large block of text (over ~64 characters), how close do
+    # the contents have to be to match the expected contents. (0.0 = perfection,
+    # 1.0 = very loose).  Note that Match_Threshold controls how closely the
+    # end points of a delete need to match.
+    self.Patch_DeleteThreshold = 0.5
+    # Chunk size for context length.
+    self.Patch_Margin = 4
+
+    # The number of bits in an int.
+    # Python has no maximum, thus to disable patch splitting set to 0.
+    # However to avoid long patches in certain pathological cases, use 32.
+    # Multiple short patches (using native ints) are much faster than long ones.
+    self.Match_MaxBits = 32
+
+  #  DIFF FUNCTIONS
+
+  # The data structure representing a diff is an array of tuples:
+  # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")]
+  # which means: delete "Hello", add "Goodbye" and keep " world."
+  DIFF_DELETE = -1
+  DIFF_INSERT = 1
+  DIFF_EQUAL = 0
+
+  def diff_main(self, text1, text2, checklines=True, deadline=None):
+    """Find the differences between two texts.  Simplifies the problem by
+      stripping any common prefix or suffix off the texts before diffing.
+
+    Args:
+      text1: Old string to be diffed.
+      text2: New string to be diffed.
+      checklines: Optional speedup flag.  If present and false, then don't run
+        a line-level diff first to identify the changed areas.
+        Defaults to true, which does a faster, slightly less optimal diff.
+      deadline: Optional time when the diff should be complete by.  Used
+        internally for recursive calls.  Users should set DiffTimeout instead.
+
+    Returns:
+      Array of changes.
+    """
+    # Set a deadline by which time the diff must be complete.
+    if deadline == None:
+      # Unlike in most languages, Python counts time in seconds.
+      if self.Diff_Timeout <= 0:
+        deadline = sys.maxint
+      else:
+        deadline = time.time() + self.Diff_Timeout
+
+    # Check for null inputs.
+    if text1 == None or text2 == None:
+      raise ValueError("Null inputs. (diff_main)")
+
+    # Check for equality (speedup).
+    if text1 == text2:
+      if text1:
+        return [(self.DIFF_EQUAL, text1)]
+      return []
+
+    # Trim off common prefix (speedup).
+    commonlength = self.diff_commonPrefix(text1, text2)
+    commonprefix = text1[:commonlength]
+    text1 = text1[commonlength:]
+    text2 = text2[commonlength:]
+
+    # Trim off common suffix (speedup).
+    commonlength = self.diff_commonSuffix(text1, text2)
+    if commonlength == 0:
+      commonsuffix = ''
+    else:
+      commonsuffix = text1[-commonlength:]
+      text1 = text1[:-commonlength]
+      text2 = text2[:-commonlength]
+
+    # Compute the diff on the middle block.
+    diffs = self.diff_compute(text1, text2, checklines, deadline)
+
+    # Restore the prefix and suffix.
+    if commonprefix:
+      diffs[:0] = [(self.DIFF_EQUAL, commonprefix)]
+    if commonsuffix:
+      diffs.append((self.DIFF_EQUAL, commonsuffix))
+    self.diff_cleanupMerge(diffs)
+    return diffs
+
+  def diff_compute(self, text1, text2, checklines, deadline):
+    """Find the differences between two texts.  Assumes that the texts do not
+      have any common prefix or suffix.
+
+    Args:
+      text1: Old string to be diffed.
+      text2: New string to be diffed.
+      checklines: Speedup flag.  If false, then don't run a line-level diff
+        first to identify the changed areas.
+        If true, then run a faster, slightly less optimal diff.
+      deadline: Time when the diff should be complete by.
+
+    Returns:
+      Array of changes.
+    """
+    if not text1:
+      # Just add some text (speedup).
+      return [(self.DIFF_INSERT, text2)]
+
+    if not text2:
+      # Just delete some text (speedup).
+      return [(self.DIFF_DELETE, text1)]
+
+    if len(text1) > len(text2):
+      (longtext, shorttext) = (text1, text2)
+    else:
+      (shorttext, longtext) = (text1, text2)
+    i = longtext.find(shorttext)
+    if i != -1:
+      # Shorter text is inside the longer text (speedup).
+      diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext),
+               (self.DIFF_INSERT, longtext[i + len(shorttext):])]
+      # Swap insertions for deletions if diff is reversed.
+      if len(text1) > len(text2):
+        diffs[0] = (self.DIFF_DELETE, diffs[0][1])
+        diffs[2] = (self.DIFF_DELETE, diffs[2][1])
+      return diffs
+
+    if len(shorttext) == 1:
+      # Single character string.
+      # After the previous speedup, the character can't be an equality.
+      return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)]
+
+    # Check to see if the problem can be split in two.
+    hm = self.diff_halfMatch(text1, text2)
+    if hm:
+      # A half-match was found, sort out the return data.
+      (text1_a, text1_b, text2_a, text2_b, mid_common) = hm
+      # Send both pairs off for separate processing.
+      diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline)
+      diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline)
+      # Merge the results.
+      return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b
+
+    if checklines and len(text1) > 100 and len(text2) > 100:
+      return self.diff_lineMode(text1, text2, deadline)
+
+    return self.diff_bisect(text1, text2, deadline)
+
+  def diff_lineMode(self, text1, text2, deadline):
+    """Do a quick line-level diff on both strings, then rediff the parts for
+      greater accuracy.
+      This speedup can produce non-minimal diffs.
+
+    Args:
+      text1: Old string to be diffed.
+      text2: New string to be diffed.
+      deadline: Time when the diff should be complete by.
+
+    Returns:
+      Array of changes.
+    """
+
+    # Scan the text on a line-by-line basis first.
+    (text1, text2, linearray) = self.diff_linesToChars(text1, text2)
+
+    diffs = self.diff_main(text1, text2, False, deadline)
+
+    # Convert the diff back to original text.
+    self.diff_charsToLines(diffs, linearray)
+    # Eliminate freak matches (e.g. blank lines)
+    self.diff_cleanupSemantic(diffs)
+
+    # Rediff any replacement blocks, this time character-by-character.
+    # Add a dummy entry at the end.
+    diffs.append((self.DIFF_EQUAL, ''))
+    pointer = 0
+    count_delete = 0
+    count_insert = 0
+    text_delete = ''
+    text_insert = ''
+    while pointer < len(diffs):
+      if diffs[pointer][0] == self.DIFF_INSERT:
+        count_insert += 1
+        text_insert += diffs[pointer][1]
+      elif diffs[pointer][0] == self.DIFF_DELETE:
+        count_delete += 1
+        text_delete += diffs[pointer][1]
+      elif diffs[pointer][0] == self.DIFF_EQUAL:
+        # Upon reaching an equality, check for prior redundancies.
+        if count_delete >= 1 and count_insert >= 1:
+          # Delete the offending records and add the merged ones.
+          a = self.diff_main(text_delete, text_insert, False, deadline)
+          diffs[pointer - count_delete - count_insert : pointer] = a
+          pointer = pointer - count_delete - count_insert + len(a)
+        count_insert = 0
+        count_delete = 0
+        text_delete = ''
+        text_insert = ''
+
+      pointer += 1
+
+    diffs.pop()  # Remove the dummy entry at the end.
+
+    return diffs
+
+  def diff_bisect(self, text1, text2, deadline):
+    """Find the 'middle snake' of a diff, split the problem in two
+      and return the recursively constructed diff.
+      See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
+
+    Args:
+      text1: Old string to be diffed.
+      text2: New string to be diffed.
+      deadline: Time at which to bail if not yet complete.
+
+    Returns:
+      Array of diff tuples.
+    """
+
+    # Cache the text lengths to prevent multiple calls.
+    text1_length = len(text1)
+    text2_length = len(text2)
+    max_d = (text1_length + text2_length + 1) // 2
+    v_offset = max_d
+    v_length = 2 * max_d
+    v1 = [-1] * v_length
+    v1[v_offset + 1] = 0
+    v2 = v1[:]
+    delta = text1_length - text2_length
+    # If the total number of characters is odd, then the front path will
+    # collide with the reverse path.
+    front = (delta % 2 != 0)
+    # Offsets for start and end of k loop.
+    # Prevents mapping of space beyond the grid.
+    k1start = 0
+    k1end = 0
+    k2start = 0
+    k2end = 0
+    for d in xrange(max_d):
+      # Bail out if deadline is reached.
+      if time.time() > deadline:
+        break
+
+      # Walk the front path one step.
+      for k1 in xrange(-d + k1start, d + 1 - k1end, 2):
+        k1_offset = v_offset + k1
+        if k1 == -d or (k1 != d and
+            v1[k1_offset - 1] < v1[k1_offset + 1]):
+          x1 = v1[k1_offset + 1]
+        else:
+          x1 = v1[k1_offset - 1] + 1
+        y1 = x1 - k1
+        while (x1 < text1_length and y1 < text2_length and
+               text1[x1] == text2[y1]):
+          x1 += 1
+          y1 += 1
+        v1[k1_offset] = x1
+        if x1 > text1_length:
+          # Ran off the right of the graph.
+          k1end += 2
+        elif y1 > text2_length:
+          # Ran off the bottom of the graph.
+          k1start += 2
+        elif front:
+          k2_offset = v_offset + delta - k1
+          if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1:
+            # Mirror x2 onto top-left coordinate system.
+            x2 = text1_length - v2[k2_offset]
+            if x1 >= x2:
+              # Overlap detected.
+              return self.diff_bisectSplit(text1, text2, x1, y1, deadline)
+
+      # Walk the reverse path one step.
+      for k2 in xrange(-d + k2start, d + 1 - k2end, 2):
+        k2_offset = v_offset + k2
+        if k2 == -d or (k2 != d and
+            v2[k2_offset - 1] < v2[k2_offset + 1]):
+          x2 = v2[k2_offset + 1]
+        else:
+          x2 = v2[k2_offset - 1] + 1
+        y2 = x2 - k2
+        while (x2 < text1_length and y2 < text2_length and
+               text1[-x2 - 1] == text2[-y2 - 1]):
+          x2 += 1
+          y2 += 1
+        v2[k2_offset] = x2
+        if x2 > text1_length:
+          # Ran off the left of the graph.
+          k2end += 2
+        elif y2 > text2_length:
+          # Ran off the top of the graph.
+          k2start += 2
+        elif not front:
+          k1_offset = v_offset + delta - k2
+          if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1:
+            x1 = v1[k1_offset]
+            y1 = v_offset + x1 - k1_offset
+            # Mirror x2 onto top-left coordinate system.
+            x2 = text1_length - x2
+            if x1 >= x2:
+              # Overlap detected.
+              return self.diff_bisectSplit(text1, text2, x1, y1, deadline)
+
+    # Diff took too long and hit the deadline or
+    # number of diffs equals number of characters, no commonality at all.
+    return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)]
+
+  def diff_bisectSplit(self, text1, text2, x, y, deadline):
+    """Given the location of the 'middle snake', split the diff in two parts
+    and recurse.
+
+    Args:
+      text1: Old string to be diffed.
+      text2: New string to be diffed.
+      x: Index of split point in text1.
+      y: Index of split point in text2.
+      deadline: Time at which to bail if not yet complete.
+
+    Returns:
+      Array of diff tuples.
+    """
+    text1a = text1[:x]
+    text2a = text2[:y]
+    text1b = text1[x:]
+    text2b = text2[y:]
+
+    # Compute both diffs serially.
+    diffs = self.diff_main(text1a, text2a, False, deadline)
+    diffsb = self.diff_main(text1b, text2b, False, deadline)
+
+    return diffs + diffsb
+
+  def diff_linesToChars(self, text1, text2):
+    """Split two texts into an array of strings.  Reduce the texts to a string
+    of hashes where each Unicode character represents one line.
+
+    Args:
+      text1: First string.
+      text2: Second string.
+
+    Returns:
+      Three element tuple, containing the encoded text1, the encoded text2 and
+      the array of unique strings.  The zeroth element of the array of unique
+      strings is intentionally blank.
+    """
+    lineArray = []  # e.g. lineArray[4] == "Hello\n"
+    lineHash = {}   # e.g. lineHash["Hello\n"] == 4
+
+    # "\x00" is a valid character, but various debuggers don't like it.
+    # So we'll insert a junk entry to avoid generating a null character.
+    lineArray.append('')
+
+    def diff_linesToCharsMunge(text):
+      """Split a text into an array of strings.  Reduce the texts to a string
+      of hashes where each Unicode character represents one line.
+      Modifies linearray and linehash through being a closure.
+
+      Args:
+        text: String to encode.
+
+      Returns:
+        Encoded string.
+      """
+      chars = []
+      # Walk the text, pulling out a substring for each line.
+      # text.split('\n') would would temporarily double our memory footprint.
+      # Modifying text would create many large strings to garbage collect.
+      lineStart = 0
+      lineEnd = -1
+      while lineEnd < len(text) - 1:
+        lineEnd = text.find('\n', lineStart)
+        if lineEnd == -1:
+          lineEnd = len(text) - 1
+        line = text[lineStart:lineEnd + 1]
+        lineStart = lineEnd + 1
+
+        if line in lineHash:
+          chars.append(unichr(lineHash[line]))
+        else:
+          lineArray.append(line)
+          lineHash[line] = len(lineArray) - 1
+          chars.append(unichr(len(lineArray) - 1))
+      return "".join(chars)
+
+    chars1 = diff_linesToCharsMunge(text1)
+    chars2 = diff_linesToCharsMunge(text2)
+    return (chars1, chars2, lineArray)
+
+  def diff_charsToLines(self, diffs, lineArray):
+    """Rehydrate the text in a diff from a string of line hashes to real lines
+    of text.
+
+    Args:
+      diffs: Array of diff tuples.
+      lineArray: Array of unique strings.
+    """
+    for x in xrange(len(diffs)):
+      text = []
+      for char in diffs[x][1]:
+        text.append(lineArray[ord(char)])
+      diffs[x] = (diffs[x][0], "".join(text))
+
+  def diff_commonPrefix(self, text1, text2):
+    """Determine the common prefix of two strings.
+
+    Args:
+      text1: First string.
+      text2: Second string.
+
+    Returns:
+      The number of characters common to the start of each string.
+    """
+    # Quick check for common null cases.
+    if not text1 or not text2 or text1[0] != text2[0]:
+      return 0
+    # Binary search.
+    # Performance analysis: http://neil.fraser.name/news/2007/10/09/
+    pointermin = 0
+    pointermax = min(len(text1), len(text2))
+    pointermid = pointermax
+    pointerstart = 0
+    while pointermin < pointermid:
+      if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]:
+        pointermin = pointermid
+        pointerstart = pointermin
+      else:
+        pointermax = pointermid
+      pointermid = (pointermax - pointermin) // 2 + pointermin
+    return pointermid
+
+  def diff_commonSuffix(self, text1, text2):
+    """Determine the common suffix of two strings.
+
+    Args:
+      text1: First string.
+      text2: Second string.
+
+    Returns:
+      The number of characters common to the end of each string.
+    """
+    # Quick check for common null cases.
+    if not text1 or not text2 or text1[-1] != text2[-1]:
+      return 0
+    # Binary search.
+    # Performance analysis: http://neil.fraser.name/news/2007/10/09/
+    pointermin = 0
+    pointermax = min(len(text1), len(text2))
+    pointermid = pointermax
+    pointerend = 0
+    while pointermin < pointermid:
+      if (text1[-pointermid:len(text1) - pointerend] ==
+          text2[-pointermid:len(text2) - pointerend]):
+        pointermin = pointermid
+        pointerend = pointermin
+      else:
+        pointermax = pointermid
+      pointermid = (pointermax - pointermin) // 2 + pointermin
+    return pointermid
+
+  def diff_commonOverlap(self, text1, text2):
+    """Determine if the suffix of one string is the prefix of another.
+
+    Args:
+      text1 First string.
+      text2 Second string.
+
+    Returns:
+      The number of characters common to the end of the first
+      string and the start of the second string.
+    """
+    # Cache the text lengths to prevent multiple calls.
+    text1_length = len(text1)
+    text2_length = len(text2)
+    # Eliminate the null case.
+    if text1_length == 0 or text2_length == 0:
+      return 0
+    # Truncate the longer string.
+    if text1_length > text2_length:
+      text1 = text1[-text2_length:]
+    elif text1_length < text2_length:
+      text2 = text2[:text1_length]
+    text_length = min(text1_length, text2_length)
+    # Quick check for the worst case.
+    if text1 == text2:
+      return text_length
+
+    # Start by looking for a single character match
+    # and increase length until no match is found.
+    # Performance analysis: http://neil.fraser.name/news/2010/11/04/
+    best = 0
+    length = 1
+    while True:
+      pattern = text1[-length:]
+      found = text2.find(pattern)
+      if found == -1:
+        return best
+      length += found
+      if found == 0 or text1[-length:] == text2[:length]:
+        best = length
+        length += 1
+
+  def diff_halfMatch(self, text1, text2):
+    """Do the two texts share a substring which is at least half the length of
+    the longer text?
+    This speedup can produce non-minimal diffs.
+
+    Args:
+      text1: First string.
+      text2: Second string.
+
+    Returns:
+      Five element Array, containing the prefix of text1, the suffix of text1,
+      the prefix of text2, the suffix of text2 and the common middle.  Or None
+      if there was no match.
+    """
+    if self.Diff_Timeout <= 0:
+      # Don't risk returning a non-optimal diff if we have unlimited time.
+      return None
+    if len(text1) > len(text2):
+      (longtext, shorttext) = (text1, text2)
+    else:
+      (shorttext, longtext) = (text1, text2)
+    if len(longtext) < 4 or len(shorttext) * 2 < len(longtext):
+      return None  # Pointless.
+
+    def diff_halfMatchI(longtext, shorttext, i):
+      """Does a substring of shorttext exist within longtext such that the
+      substring is at least half the length of longtext?
+      Closure, but does not reference any external variables.
+
+      Args:
+        longtext: Longer string.
+        shorttext: Shorter string.
+        i: Start index of quarter length substring within longtext.
+
+      Returns:
+        Five element Array, containing the prefix of longtext, the suffix of
+        longtext, the prefix of shorttext, the suffix of shorttext and the
+        common middle.  Or None if there was no match.
+      """
+      seed = longtext[i:i + len(longtext) // 4]
+      best_common = ''
+      j = shorttext.find(seed)
+      while j != -1:
+        prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:])
+        suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j])
+        if len(best_common) < suffixLength + prefixLength:
+          best_common = (shorttext[j - suffixLength:j] +
+              shorttext[j:j + prefixLength])
+          best_longtext_a = longtext[:i - suffixLength]
+          best_longtext_b = longtext[i + prefixLength:]
+          best_shorttext_a = shorttext[:j - suffixLength]
+          best_shorttext_b = shorttext[j + prefixLength:]
+        j = shorttext.find(seed, j + 1)
+
+      if len(best_common) * 2 >= len(longtext):
+        return (best_longtext_a, best_longtext_b,
+                best_shorttext_a, best_shorttext_b, best_common)
+      else:
+        return None
+
+    # First check if the second quarter is the seed for a half-match.
+    hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4)
+    # Check again based on the third quarter.
+    hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2)
+    if not hm1 and not hm2:
+      return None
+    elif not hm2:
+      hm = hm1
+    elif not hm1:
+      hm = hm2
+    else:
+      # Both matched.  Select the longest.
+      if len(hm1[4]) > len(hm2[4]):
+        hm = hm1
+      else:
+        hm = hm2
+
+    # A half-match was found, sort out the return data.
+    if len(text1) > len(text2):
+      (text1_a, text1_b, text2_a, text2_b, mid_common) = hm
+    else:
+      (text2_a, text2_b, text1_a, text1_b, mid_common) = hm
+    return (text1_a, text1_b, text2_a, text2_b, mid_common)
+
+  def diff_cleanupSemantic(self, diffs):
+    """Reduce the number of edits by eliminating semantically trivial
+    equalities.
+
+    Args:
+      diffs: Array of diff tuples.
+    """
+    changes = False
+    equalities = []  # Stack of indices where equalities are found.
+    lastequality = None  # Always equal to diffs[equalities[-1]][1]
+    pointer = 0  # Index of current position.
+    # Number of chars that changed prior to the equality.
+    length_insertions1, length_deletions1 = 0, 0
+    # Number of chars that changed after the equality.
+    length_insertions2, length_deletions2 = 0, 0
+    while pointer < len(diffs):
+      if diffs[pointer][0] == self.DIFF_EQUAL:  # Equality found.
+        equalities.append(pointer)
+        length_insertions1, length_insertions2 = length_insertions2, 0
+        length_deletions1, length_deletions2 = length_deletions2, 0
+        lastequality = diffs[pointer][1]
+      else:  # An insertion or deletion.
+        if diffs[pointer][0] == self.DIFF_INSERT:
+          length_insertions2 += len(diffs[pointer][1])
+        else:
+          length_deletions2 += len(diffs[pointer][1])
+        # Eliminate an equality that is smaller or equal to the edits on both
+        # sides of it.
+        if (lastequality and (len(lastequality) <=
+            max(length_insertions1, length_deletions1)) and
+            (len(lastequality) <= max(length_insertions2, length_deletions2))):
+          # Duplicate record.
+          diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality))
+          # Change second copy to insert.
+          diffs[equalities[-1] + 1] = (self.DIFF_INSERT,
+              diffs[equalities[-1] + 1][1])
+          # Throw away the equality we just deleted.
+          equalities.pop()
+          # Throw away the previous equality (it needs to be reevaluated).
+          if len(equalities):
+            equalities.pop()
+          if len(equalities):
+            pointer = equalities[-1]
+          else:
+            pointer = -1
+          # Reset the counters.
+          length_insertions1, length_deletions1 = 0, 0
+          length_insertions2, length_deletions2 = 0, 0
+          lastequality = None
+          changes = True
+      pointer += 1
+
+    # Normalize the diff.
+    if changes:
+      self.diff_cleanupMerge(diffs)
+    self.diff_cleanupSemanticLossless(diffs)
+
+    # Find any overlaps between deletions and insertions.
+    # e.g: <del>abcxxx</del><ins>xxxdef</ins>
+    #   -> <del>abc</del>xxx<ins>def</ins>
+    # e.g: <del>xxxabc</del><ins>defxxx</ins>
+    #   -> <ins>def</ins>xxx<del>abc</del>
+    # Only extract an overlap if it is as big as the edit ahead or behind it.
+    pointer = 1
+    while pointer < len(diffs):
+      if (diffs[pointer - 1][0] == self.DIFF_DELETE and
+          diffs[pointer][0] == self.DIFF_INSERT):
+        deletion = diffs[pointer - 1][1]
+        insertion = diffs[pointer][1]
+        overlap_length1 = self.diff_commonOverlap(deletion, insertion)
+        overlap_length2 = self.diff_commonOverlap(insertion, deletion)
+        if overlap_length1 >= overlap_length2:
+          if (overlap_length1 >= len(deletion) / 2.0 or
+              overlap_length1 >= len(insertion) / 2.0):
+            # Overlap found.  Insert an equality and trim the surrounding edits.
+            diffs.insert(pointer, (self.DIFF_EQUAL,
+                                   insertion[:overlap_length1]))
+            diffs[pointer - 1] = (self.DIFF_DELETE,
+                                  deletion[:len(deletion) - overlap_length1])
+            diffs[pointer + 1] = (self.DIFF_INSERT,
+                                  insertion[overlap_length1:])
+            pointer += 1
+        else:
+          if (overlap_length2 >= len(deletion) / 2.0 or
+              overlap_length2 >= len(insertion) / 2.0):
+            # Reverse overlap found.
+            # Insert an equality and swap and trim the surrounding edits.
+            diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2]))
+            diffs[pointer - 1] = (self.DIFF_INSERT,
+                                  insertion[:len(insertion) - overlap_length2])
+            diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:])
+            pointer += 1
+        pointer += 1
+      pointer += 1
+
+  def diff_cleanupSemanticLossless(self, diffs):
+    """Look for single edits surrounded on both sides by equalities
+    which can be shifted sideways to align the edit to a word boundary.
+    e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
+
+    Args:
+      diffs: Array of diff tuples.
+    """
+
+    def diff_cleanupSemanticScore(one, two):
+      """Given two strings, compute a score representing whether the
+      internal boundary falls on logical boundaries.
+      Scores range from 6 (best) to 0 (worst).
+      Closure, but does not reference any external variables.
+
+      Args:
+        one: First string.
+        two: Second string.
+
+      Returns:
+        The score.
+      """
+      if not one or not two:
+        # Edges are the best.
+        return 6
+
+      # Each port of this function behaves slightly differently due to
+      # subtle differences in each language's definition of things like
+      # 'whitespace'.  Since this function's purpose is largely cosmetic,
+      # the choice has been made to use each language's native features
+      # rather than force total conformity.
+      char1 = one[-1]
+      char2 = two[0]
+      nonAlphaNumeric1 = not char1.isalnum()
+      nonAlphaNumeric2 = not char2.isalnum()
+      whitespace1 = nonAlphaNumeric1 and char1.isspace()
+      whitespace2 = nonAlphaNumeric2 and char2.isspace()
+      lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n")
+      lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n")
+      blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one)
+      blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two)
+
+      if blankLine1 or blankLine2:
+        # Five points for blank lines.
+        return 5
+      elif lineBreak1 or lineBreak2:
+        # Four points for line breaks.
+        return 4
+      elif nonAlphaNumeric1 and not whitespace1 and whitespace2:
+        # Three points for end of sentences.
+        return 3
+      elif whitespace1 or whitespace2:
+        # Two points for whitespace.
+        return 2
+      elif nonAlphaNumeric1 or nonAlphaNumeric2:
+        # One point for non-alphanumeric.
+        return 1
+      return 0
+
+    pointer = 1
+    # Intentionally ignore the first and last element (don't need checking).
+    while pointer < len(diffs) - 1:
+      if (diffs[pointer - 1][0] == self.DIFF_EQUAL and
+          diffs[pointer + 1][0] == self.DIFF_EQUAL):
+        # This is a single edit surrounded by equalities.
+        equality1 = diffs[pointer - 1][1]
+        edit = diffs[pointer][1]
+        equality2 = diffs[pointer + 1][1]
+
+        # First, shift the edit as far left as possible.
+        commonOffset = self.diff_commonSuffix(equality1, edit)
+        if commonOffset:
+          commonString = edit[-commonOffset:]
+          equality1 = equality1[:-commonOffset]
+          edit = commonString + edit[:-commonOffset]
+          equality2 = commonString + equality2
+
+        # Second, step character by character right, looking for the best fit.
+        bestEquality1 = equality1
+        bestEdit = edit
+        bestEquality2 = equality2
+        bestScore = (diff_cleanupSemanticScore(equality1, edit) +
+            diff_cleanupSemanticScore(edit, equality2))
+        while edit and equality2 and edit[0] == equality2[0]:
+          equality1 += edit[0]
+          edit = edit[1:] + equality2[0]
+          equality2 = equality2[1:]
+          score = (diff_cleanupSemanticScore(equality1, edit) +
+              diff_cleanupSemanticScore(edit, equality2))
+          # The >= encourages trailing rather than leading whitespace on edits.
+          if score >= bestScore:
+            bestScore = score
+            bestEquality1 = equality1
+            bestEdit = edit
+            bestEquality2 = equality2
+
+        if diffs[pointer - 1][1] != bestEquality1:
+          # We have an improvement, save it back to the diff.
+          if bestEquality1:
+            diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1)
+          else:
+            del diffs[pointer - 1]
+            pointer -= 1
+          diffs[pointer] = (diffs[pointer][0], bestEdit)
+          if bestEquality2:
+            diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2)
+          else:
+            del diffs[pointer + 1]
+            pointer -= 1
+      pointer += 1
+
+  # Define some regex patterns for matching boundaries.
+  BLANKLINEEND = re.compile(r"\n\r?\n$");
+  BLANKLINESTART = re.compile(r"^\r?\n\r?\n");
+
+  def diff_cleanupEfficiency(self, diffs):
+    """Reduce the number of edits by eliminating operationally trivial
+    equalities.
+
+    Args:
+      diffs: Array of diff tuples.
+    """
+    changes = False
+    equalities = []  # Stack of indices where equalities are found.
+    lastequality = None  # Always equal to diffs[equalities[-1]][1]
+    pointer = 0  # Index of current position.
+    pre_ins = False  # Is there an insertion operation before the last equality.
+    pre_del = False  # Is there a deletion operation before the last equality.
+    post_ins = False  # Is there an insertion operation after the last equality.
+    post_del = False  # Is there a deletion operation after the last equality.
+    while pointer < len(diffs):
+      if diffs[pointer][0] == self.DIFF_EQUAL:  # Equality found.
+        if (len(diffs[pointer][1]) < self.Diff_EditCost and
+            (post_ins or post_del)):
+          # Candidate found.
+          equalities.append(pointer)
+          pre_ins = post_ins
+          pre_del = post_del
+          lastequality = diffs[pointer][1]
+        else:
+          # Not a candidate, and can never become one.
+          equalities = []
+          lastequality = None
+
+        post_ins = post_del = False
+      else:  # An insertion or deletion.
+        if diffs[pointer][0] == self.DIFF_DELETE:
+          post_del = True
+        else:
+          post_ins = True
+
+        # Five types to be split:
+        # <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
+        # <ins>A</ins>X<ins>C</ins><del>D</del>
+        # <ins>A</ins><del>B</del>X<ins>C</ins>
+        # <ins>A</del>X<ins>C</ins><del>D</del>
+        # <ins>A</ins><del>B</del>X<del>C</del>
+
+        if lastequality and ((pre_ins and pre_del and post_ins and post_del) or
+                             ((len(lastequality) < self.Diff_EditCost / 2) and
+                              (pre_ins + pre_del + post_ins + post_del) == 3)):
+          # Duplicate record.
+          diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality))
+          # Change second copy to insert.
+          diffs[equalities[-1] + 1] = (self.DIFF_INSERT,
+              diffs[equalities[-1] + 1][1])
+          equalities.pop()  # Throw away the equality we just deleted.
+          lastequality = None
+          if pre_ins and pre_del:
+            # No changes made which could affect previous entry, keep going.
+            post_ins = post_del = True
+            equalities = []
+          else:
+            if len(equalities):
+              equalities.pop()  # Throw away the previous equality.
+            if len(equalities):
+              pointer = equalities[-1]
+            else:
+              pointer = -1
+            post_ins = post_del = False
+          changes = True
+      pointer += 1
+
+    if changes:
+      self.diff_cleanupMerge(diffs)
+
+  def diff_cleanupMerge(self, diffs):
+    """Reorder and merge like edit sections.  Merge equalities.
+    Any edit section can move as long as it doesn't cross an equality.
+
+    Args:
+      diffs: Array of diff tuples.
+    """
+    diffs.append((self.DIFF_EQUAL, ''))  # Add a dummy entry at the end.
+    pointer = 0
+    count_delete = 0
+    count_insert = 0
+    text_delete = ''
+    text_insert = ''
+    while pointer < len(diffs):
+      if diffs[pointer][0] == self.DIFF_INSERT:
+        count_insert += 1
+        text_insert += diffs[pointer][1]
+        pointer += 1
+      elif diffs[pointer][0] == self.DIFF_DELETE:
+        count_delete += 1
+        text_delete += diffs[pointer][1]
+        pointer += 1
+      elif diffs[pointer][0] == self.DIFF_EQUAL:
+        # Upon reaching an equality, check for prior redundancies.
+        if count_delete + count_insert > 1:
+          if count_delete != 0 and count_insert != 0:
+            # Factor out any common prefixies.
+            commonlength = self.diff_commonPrefix(text_insert, text_delete)
+            if commonlength != 0:
+              x = pointer - count_delete - count_insert - 1
+              if x >= 0 and diffs[x][0] == self.DIFF_EQUAL:
+                diffs[x] = (diffs[x][0], diffs[x][1] +
+                            text_insert[:commonlength])
+              else:
+                diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength]))
+                pointer += 1
+              text_insert = text_insert[commonlength:]
+              text_delete = text_delete[commonlength:]
+            # Factor out any common suffixies.
+            commonlength = self.diff_commonSuffix(text_insert, text_delete)
+            if commonlength != 0:
+              diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] +
+                  diffs[pointer][1])
+              text_insert = text_insert[:-commonlength]
+              text_delete = text_delete[:-commonlength]
+          # Delete the offending records and add the merged ones.
+          if count_delete == 0:
+            diffs[pointer - count_insert : pointer] = [
+                (self.DIFF_INSERT, text_insert)]
+          elif count_insert == 0:
+            diffs[pointer - count_delete : pointer] = [
+                (self.DIFF_DELETE, text_delete)]
+          else:
+            diffs[pointer - count_delete - count_insert : pointer] = [
+                (self.DIFF_DELETE, text_delete),
+                (self.DIFF_INSERT, text_insert)]
+          pointer = pointer - count_delete - count_insert + 1
+          if count_delete != 0:
+            pointer += 1
+          if count_insert != 0:
+            pointer += 1
+        elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL:
+          # Merge this equality with the previous one.
+          diffs[pointer - 1] = (diffs[pointer - 1][0],
+                                diffs[pointer - 1][1] + diffs[pointer][1])
+          del diffs[pointer]
+        else:
+          pointer += 1
+
+        count_insert = 0
+        count_delete = 0
+        text_delete = ''
+        text_insert = ''
+
+    if diffs[-1][1] == '':
+      diffs.pop()  # Remove the dummy entry at the end.
+
+    # Second pass: look for single edits surrounded on both sides by equalities
+    # which can be shifted sideways to eliminate an equality.
+    # e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
+    changes = False
+    pointer = 1
+    # Intentionally ignore the first and last element (don't need checking).
+    while pointer < len(diffs) - 1:
+      if (diffs[pointer - 1][0] == self.DIFF_EQUAL and
+          diffs[pointer + 1][0] == self.DIFF_EQUAL):
+        # This is a single edit surrounded by equalities.
+        if diffs[pointer][1].endswith(diffs[pointer - 1][1]):
+          # Shift the edit over the previous equality.
+          diffs[pointer] = (diffs[pointer][0],
+              diffs[pointer - 1][1] +
+              diffs[pointer][1][:-len(diffs[pointer - 1][1])])
+          diffs[pointer + 1] = (diffs[pointer + 1][0],
+                                diffs[pointer - 1][1] + diffs[pointer + 1][1])
+          del diffs[pointer - 1]
+          changes = True
+        elif diffs[pointer][1].startswith(diffs[pointer + 1][1]):
+          # Shift the edit over the next equality.
+          diffs[pointer - 1] = (diffs[pointer - 1][0],
+                                diffs[pointer - 1][1] + diffs[pointer + 1][1])
+          diffs[pointer] = (diffs[pointer][0],
+              diffs[pointer][1][len(diffs[pointer + 1][1]):] +
+              diffs[pointer + 1][1])
+          del diffs[pointer + 1]
+          changes = True
+      pointer += 1
+
+    # If shifts were made, the diff needs reordering and another shift sweep.
+    if changes:
+      self.diff_cleanupMerge(diffs)
+
+  def diff_xIndex(self, diffs, loc):
+    """loc is a location in text1, compute and return the equivalent location
+    in text2.  e.g. "The cat" vs "The big cat", 1->1, 5->8
+
+    Args:
+      diffs: Array of diff tuples.
+      loc: Location within text1.
+
+    Returns:
+      Location within text2.
+    """
+    chars1 = 0
+    chars2 = 0
+    last_chars1 = 0
+    last_chars2 = 0
+    for x in xrange(len(diffs)):
+      (op, text) = diffs[x]
+      if op != self.DIFF_INSERT:  # Equality or deletion.
+        chars1 += len(text)
+      if op != self.DIFF_DELETE:  # Equality or insertion.
+        chars2 += len(text)
+      if chars1 > loc:  # Overshot the location.
+        break
+      last_chars1 = chars1
+      last_chars2 = chars2
+
+    if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE:
+      # The location was deleted.
+      return last_chars2
+    # Add the remaining len(character).
+    return last_chars2 + (loc - last_chars1)
+
+  def diff_prettyHtml(self, diffs):
+    """Convert a diff array into a pretty HTML report.
+
+    Args:
+      diffs: Array of diff tuples.
+
+    Returns:
+      HTML representation.
+    """
+    html = []
+    for (op, data) in diffs:
+      text = (data.replace("&", "&amp;").replace("<", "&lt;")
+                 .replace(">", "&gt;").replace("\n", "&para;<br>"))
+      if op == self.DIFF_INSERT:
+        html.append("<ins style=\"background:#e6ffe6;\">%s</ins>" % text)
+      elif op == self.DIFF_DELETE:
+        html.append("<del style=\"background:#ffe6e6;\">%s</del>" % text)
+      elif op == self.DIFF_EQUAL:
+        html.append("<span>%s</span>" % text)
+    return "".join(html)
+
+  def diff_text1(self, diffs):
+    """Compute and return the source text (all equalities and deletions).
+
+    Args:
+      diffs: Array of diff tuples.
+
+    Returns:
+      Source text.
+    """
+    text = []
+    for (op, data) in diffs:
+      if op != self.DIFF_INSERT:
+        text.append(data)
+    return "".join(text)
+
+  def diff_text2(self, diffs):
+    """Compute and return the destination text (all equalities and insertions).
+
+    Args:
+      diffs: Array of diff tuples.
+
+    Returns:
+      Destination text.
+    """
+    text = []
+    for (op, data) in diffs:
+      if op != self.DIFF_DELETE:
+        text.append(data)
+    return "".join(text)
+
+  def diff_levenshtein(self, diffs):
+    """Compute the Levenshtein distance; the number of inserted, deleted or
+    substituted characters.
+
+    Args:
+      diffs: Array of diff tuples.
+
+    Returns:
+      Number of changes.
+    """
+    levenshtein = 0
+    insertions = 0
+    deletions = 0
+    for (op, data) in diffs:
+      if op == self.DIFF_INSERT:
+        insertions += len(data)
+      elif op == self.DIFF_DELETE:
+        deletions += len(data)
+      elif op == self.DIFF_EQUAL:
+        # A deletion and an insertion is one substitution.
+        levenshtein += max(insertions, deletions)
+        insertions = 0
+        deletions = 0
+    levenshtein += max(insertions, deletions)
+    return levenshtein
+
+  def diff_toDelta(self, diffs):
+    """Crush the diff into an encoded string which describes the operations
+    required to transform text1 into text2.
+    E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
+    Operations are tab-separated.  Inserted text is escaped using %xx notation.
+
+    Args:
+      diffs: Array of diff tuples.
+
+    Returns:
+      Delta text.
+    """
+    text = []
+    for (op, data) in diffs:
+      if op == self.DIFF_INSERT:
+        # High ascii will raise UnicodeDecodeError.  Use Unicode instead.
+        data = data.encode("utf-8")
+        text.append("+" + urllib.quote(data, "!~*'();/?:@&=+$,# "))
+      elif op == self.DIFF_DELETE:
+        text.append("-%d" % len(data))
+      elif op == self.DIFF_EQUAL:
+        text.append("=%d" % len(data))
+    return "\t".join(text)
+
+  def diff_fromDelta(self, text1, delta):
+    """Given the original text1, and an encoded string which describes the
+    operations required to transform text1 into text2, compute the full diff.
+
+    Args:
+      text1: Source string for the diff.
+      delta: Delta text.
+
+    Returns:
+      Array of diff tuples.
+
+    Raises:
+      ValueError: If invalid input.
+    """
+    if type(delta) == unicode:
+      # Deltas should be composed of a subset of ascii chars, Unicode not
+      # required.  If this encode raises UnicodeEncodeError, delta is invalid.
+      delta = delta.encode("ascii")
+    diffs = []
+    pointer = 0  # Cursor in text1
+    tokens = delta.split("\t")
+    for token in tokens:
+      if token == "":
+        # Blank tokens are ok (from a trailing \t).
+        continue
+      # Each token begins with a one character parameter which specifies the
+      # operation of this token (delete, insert, equality).
+      param = token[1:]
+      if token[0] == "+":
+        param = urllib.unquote(param).decode("utf-8")
+        diffs.append((self.DIFF_INSERT, param))
+      elif token[0] == "-" or token[0] == "=":
+        try:
+          n = int(param)
+        except ValueError:
+          raise ValueError("Invalid number in diff_fromDelta: " + param)
+        if n < 0:
+          raise ValueError("Negative number in diff_fromDelta: " + param)
+        text = text1[pointer : pointer + n]
+        pointer += n
+        if token[0] == "=":
+          diffs.append((self.DIFF_EQUAL, text))
+        else:
+          diffs.append((self.DIFF_DELETE, text))
+      else:
+        # Anything else is an error.
+        raise ValueError("Invalid diff operation in diff_fromDelta: " +
+            token[0])
+    if pointer != len(text1):
+      raise ValueError(
+          "Delta length (%d) does not equal source text length (%d)." %
+         (pointer, len(text1)))
+    return diffs
+
+  #  MATCH FUNCTIONS
+
+  def match_main(self, text, pattern, loc):
+    """Locate the best instance of 'pattern' in 'text' near 'loc'.
+
+    Args:
+      text: The text to search.
+      pattern: The pattern to search for.
+      loc: The location to search around.
+
+    Returns:
+      Best match index or -1.
+    """
+    # Check for null inputs.
+    if text == None or pattern == None:
+      raise ValueError("Null inputs. (match_main)")
+
+    loc = max(0, min(loc, len(text)))
+    if text == pattern:
+      # Shortcut (potentially not guaranteed by the algorithm)
+      return 0
+    elif not text:
+      # Nothing to match.
+      return -1
+    elif text[loc:loc + len(pattern)] == pattern:
+      # Perfect match at the perfect spot!  (Includes case of null pattern)
+      return loc
+    else:
+      # Do a fuzzy compare.
+      match = self.match_bitap(text, pattern, loc)
+      return match
+
+  def match_bitap(self, text, pattern, loc):
+    """Locate the best instance of 'pattern' in 'text' near 'loc' using the
+    Bitap algorithm.
+
+    Args:
+      text: The text to search.
+      pattern: The pattern to search for.
+      loc: The location to search around.
+
+    Returns:
+      Best match index or -1.
+    """
+    # Python doesn't have a maxint limit, so ignore this check.
+    #if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits:
+    #  raise ValueError("Pattern too long for this application.")
+
+    # Initialise the alphabet.
+    s = self.match_alphabet(pattern)
+
+    def match_bitapScore(e, x):
+      """Compute and return the score for a match with e errors and x location.
+      Accesses loc and pattern through being a closure.
+
+      Args:
+        e: Number of errors in match.
+        x: Location of match.
+
+      Returns:
+        Overall score for match (0.0 = good, 1.0 = bad).
+      """
+      accuracy = float(e) / len(pattern)
+      proximity = abs(loc - x)
+      if not self.Match_Distance:
+        # Dodge divide by zero error.
+        return proximity and 1.0 or accuracy
+      return accuracy + (proximity / float(self.Match_Distance))
+
+    # Highest score beyond which we give up.
+    score_threshold = self.Match_Threshold
+    # Is there a nearby exact match? (speedup)
+    best_loc = text.find(pattern, loc)
+    if best_loc != -1:
+      score_threshold = min(match_bitapScore(0, best_loc), score_threshold)
+      # What about in the other direction? (speedup)
+      best_loc = text.rfind(pattern, loc + len(pattern))
+      if best_loc != -1:
+        score_threshold = min(match_bitapScore(0, best_loc), score_threshold)
+
+    # Initialise the bit arrays.
+    matchmask = 1 << (len(pattern) - 1)
+    best_loc = -1
+
+    bin_max = len(pattern) + len(text)
+    # Empty initialization added to appease pychecker.
+    last_rd = None
+    for d in xrange(len(pattern)):
+      # Scan for the best match each iteration allows for one more error.
+      # Run a binary search to determine how far from 'loc' we can stray at
+      # this error level.
+      bin_min = 0
+      bin_mid = bin_max
+      while bin_min < bin_mid:
+        if match_bitapScore(d, loc + bin_mid) <= score_threshold:
+          bin_min = bin_mid
+        else:
+          bin_max = bin_mid
+        bin_mid = (bin_max - bin_min) // 2 + bin_min
+
+      # Use the result from this iteration as the maximum for the next.
+      bin_max = bin_mid
+      start = max(1, loc - bin_mid + 1)
+      finish = min(loc + bin_mid, len(text)) + len(pattern)
+
+      rd = [0] * (finish + 2)
+      rd[finish + 1] = (1 << d) - 1
+      for j in xrange(finish, start - 1, -1):
+        if len(text) <= j - 1:
+          # Out of range.
+          charMatch = 0
+        else:
+          charMatch = s.get(text[j - 1], 0)
+        if d == 0:  # First pass: exact match.
+          rd[j] = ((rd[j + 1] << 1) | 1) & charMatch
+        else:  # Subsequent passes: fuzzy match.
+          rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | (
+              ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1]
+        if rd[j] & matchmask:
+          score = match_bitapScore(d, j - 1)
+          # This match will almost certainly be better than any existing match.
+          # But check anyway.
+          if score <= score_threshold:
+            # Told you so.
+            score_threshold = score
+            best_loc = j - 1
+            if best_loc > loc:
+              # When passing loc, don't exceed our current distance from loc.
+              start = max(1, 2 * loc - best_loc)
+            else:
+              # Already passed loc, downhill from here on in.
+              break
+      # No hope for a (better) match at greater error levels.
+      if match_bitapScore(d + 1, loc) > score_threshold:
+        break
+      last_rd = rd
+    return best_loc
+
+  def match_alphabet(self, pattern):
+    """Initialise the alphabet for the Bitap algorithm.
+
+    Args:
+      pattern: The text to encode.
+
+    Returns:
+      Hash of character locations.
+    """
+    s = {}
+    for char in pattern:
+      s[char] = 0
+    for i in xrange(len(pattern)):
+      s[pattern[i]] |= 1 << (len(pattern) - i - 1)
+    return s
+
+  #  PATCH FUNCTIONS
+
+  def patch_addContext(self, patch, text):
+    """Increase the context until it is unique,
+    but don't let the pattern expand beyond Match_MaxBits.
+
+    Args:
+      patch: The patch to grow.
+      text: Source text.
+    """
+    if len(text) == 0:
+      return
+    pattern = text[patch.start2 : patch.start2 + patch.length1]
+    padding = 0
+
+    # Look for the first and last matches of pattern in text.  If two different
+    # matches are found, increase the pattern length.
+    while (text.find(pattern) != text.rfind(pattern) and (self.Match_MaxBits ==
+        0 or len(pattern) < self.Match_MaxBits - self.Patch_Margin -
+        self.Patch_Margin)):
+      padding += self.Patch_Margin
+      pattern = text[max(0, patch.start2 - padding) :
+                     patch.start2 + patch.length1 + padding]
+    # Add one chunk for good luck.
+    padding += self.Patch_Margin
+
+    # Add the prefix.
+    prefix = text[max(0, patch.start2 - padding) : patch.start2]
+    if prefix:
+      patch.diffs[:0] = [(self.DIFF_EQUAL, prefix)]
+    # Add the suffix.
+    suffix = text[patch.start2 + patch.length1 :
+                  patch.start2 + patch.length1 + padding]
+    if suffix:
+      patch.diffs.append((self.DIFF_EQUAL, suffix))
+
+    # Roll back the start points.
+    patch.start1 -= len(prefix)
+    patch.start2 -= len(prefix)
+    # Extend lengths.
+    patch.length1 += len(prefix) + len(suffix)
+    patch.length2 += len(prefix) + len(suffix)
+
+  def patch_make(self, a, b=None, c=None):
+    """Compute a list of patches to turn text1 into text2.
+    Use diffs if provided, otherwise compute it ourselves.
+    There are four ways to call this function, depending on what data is
+    available to the caller:
+    Method 1:
+    a = text1, b = text2
+    Method 2:
+    a = diffs
+    Method 3 (optimal):
+    a = text1, b = diffs
+    Method 4 (deprecated, use method 3):
+    a = text1, b = text2, c = diffs
+
+    Args:
+      a: text1 (methods 1,3,4) or Array of diff tuples for text1 to
+          text2 (method 2).
+      b: text2 (methods 1,4) or Array of diff tuples for text1 to
+          text2 (method 3) or undefined (method 2).
+      c: Array of diff tuples for text1 to text2 (method 4) or
+          undefined (methods 1,2,3).
+
+    Returns:
+      Array of Patch objects.
+    """
+    text1 = None
+    diffs = None
+    # Note that texts may arrive as 'str' or 'unicode'.
+    if isinstance(a, basestring) and isinstance(b, basestring) and c is None:
+      # Method 1: text1, text2
+      # Compute diffs from text1 and text2.
+      text1 = a
+      diffs = self.diff_main(text1, b, True)
+      if len(diffs) > 2:
+        self.diff_cleanupSemantic(diffs)
+        self.diff_cleanupEfficiency(diffs)
+    elif isinstance(a, list) and b is None and c is None:
+      # Method 2: diffs
+      # Compute text1 from diffs.
+      diffs = a
+      text1 = self.diff_text1(diffs)
+    elif isinstance(a, basestring) and isinstance(b, list) and c is None:
+      # Method 3: text1, diffs
+      text1 = a
+      diffs = b
+    elif (isinstance(a, basestring) and isinstance(b, basestring) and
+          isinstance(c, list)):
+      # Method 4: text1, text2, diffs
+      # text2 is not used.
+      text1 = a
+      diffs = c
+    else:
+      raise ValueError("Unknown call format to patch_make.")
+
+    if not diffs:
+      return []  # Get rid of the None case.
+    patches = []
+    patch = patch_obj()
+    char_count1 = 0  # Number of characters into the text1 string.
+    char_count2 = 0  # Number of characters into the text2 string.
+    prepatch_text = text1  # Recreate the patches to determine context info.
+    postpatch_text = text1
+    for x in xrange(len(diffs)):
+      (diff_type, diff_text) = diffs[x]
+      if len(patch.diffs) == 0 and diff_type != self.DIFF_EQUAL:
+        # A new patch starts here.
+        patch.start1 = char_count1
+        patch.start2 = char_count2
+      if diff_type == self.DIFF_INSERT:
+        # Insertion
+        patch.diffs.append(diffs[x])
+        patch.length2 += len(diff_text)
+        postpatch_text = (postpatch_text[:char_count2] + diff_text +
+                          postpatch_text[char_count2:])
+      elif diff_type == self.DIFF_DELETE:
+        # Deletion.
+        patch.length1 += len(diff_text)
+        patch.diffs.append(diffs[x])
+        postpatch_text = (postpatch_text[:char_count2] +
+                          postpatch_text[char_count2 + len(diff_text):])
+      elif (diff_type == self.DIFF_EQUAL and
+            len(diff_text) <= 2 * self.Patch_Margin and
+            len(patch.diffs) != 0 and len(diffs) != x + 1):
+        # Small equality inside a patch.
+        patch.diffs.append(diffs[x])
+        patch.length1 += len(diff_text)
+        patch.length2 += len(diff_text)
+
+      if (diff_type == self.DIFF_EQUAL and
+          len(diff_text) >= 2 * self.Patch_Margin):
+        # Time for a new patch.
+        if len(patch.diffs) != 0:
+          self.patch_addContext(patch, prepatch_text)
+          patches.append(patch)
+          patch = patch_obj()
+          # Unlike Unidiff, our patch lists have a rolling context.
+          # http://code.google.com/p/google-diff-match-patch/wiki/Unidiff
+          # Update prepatch text & pos to reflect the application of the
+          # just completed patch.
+          prepatch_text = postpatch_text
+          char_count1 = char_count2
+
+      # Update the current character count.
+      if diff_type != self.DIFF_INSERT:
+        char_count1 += len(diff_text)
+      if diff_type != self.DIFF_DELETE:
+        char_count2 += len(diff_text)
+
+    # Pick up the leftover patch if not empty.
+    if len(patch.diffs) != 0:
+      self.patch_addContext(patch, prepatch_text)
+      patches.append(patch)
+    return patches
+
+  def patch_deepCopy(self, patches):
+    """Given an array of patches, return another array that is identical.
+
+    Args:
+      patches: Array of Patch objects.
+
+    Returns:
+      Array of Patch objects.
+    """
+    patchesCopy = []
+    for patch in patches:
+      patchCopy = patch_obj()
+      # No need to deep copy the tuples since they are immutable.
+      patchCopy.diffs = patch.diffs[:]
+      patchCopy.start1 = patch.start1
+      patchCopy.start2 = patch.start2
+      patchCopy.length1 = patch.length1
+      patchCopy.length2 = patch.length2
+      patchesCopy.append(patchCopy)
+    return patchesCopy
+
+  def patch_apply(self, patches, text):
+    """Merge a set of patches onto the text.  Return a patched text, as well
+    as a list of true/false values indicating which patches were applied.
+
+    Args:
+      patches: Array of Patch objects.
+      text: Old text.
+
+    Returns:
+      Two element Array, containing the new text and an array of boolean values.
+    """
+    if not patches:
+      return (text, [])
+
+    # Deep copy the patches so that no changes are made to originals.
+    patches = self.patch_deepCopy(patches)
+
+    nullPadding = self.patch_addPadding(patches)
+    text = nullPadding + text + nullPadding
+    self.patch_splitMax(patches)
+
+    # delta keeps track of the offset between the expected and actual location
+    # of the previous patch.  If there are patches expected at positions 10 and
+    # 20, but the first patch was found at 12, delta is 2 and the second patch
+    # has an effective expected position of 22.
+    delta = 0
+    results = []
+    for patch in patches:
+      expected_loc = patch.start2 + delta
+      text1 = self.diff_text1(patch.diffs)
+      end_loc = -1
+      if len(text1) > self.Match_MaxBits:
+        # patch_splitMax will only provide an oversized pattern in the case of
+        # a monster delete.
+        start_loc = self.match_main(text, text1[:self.Match_MaxBits],
+                                    expected_loc)
+        if start_loc != -1:
+          end_loc = self.match_main(text, text1[-self.Match_MaxBits:],
+              expected_loc + len(text1) - self.Match_MaxBits)
+          if end_loc == -1 or start_loc >= end_loc:
+            # Can't find valid trailing context.  Drop this patch.
+            start_loc = -1
+      else:
+        start_loc = self.match_main(text, text1, expected_loc)
+      if start_loc == -1:
+        # No match found.  :(
+        results.append(False)
+        # Subtract the delta for this failed patch from subsequent patches.
+        delta -= patch.length2 - patch.length1
+      else:
+        # Found a match.  :)
+        results.append(True)
+        delta = start_loc - expected_loc
+        if end_loc == -1:
+          text2 = text[start_loc : start_loc + len(text1)]
+        else:
+          text2 = text[start_loc : end_loc + self.Match_MaxBits]
+        if text1 == text2:
+          # Perfect match, just shove the replacement text in.
+          text = (text[:start_loc] + self.diff_text2(patch.diffs) +
+                      text[start_loc + len(text1):])
+        else:
+          # Imperfect match.
+          # Run a diff to get a framework of equivalent indices.
+          diffs = self.diff_main(text1, text2, False)
+          if (len(text1) > self.Match_MaxBits and
+              self.diff_levenshtein(diffs) / float(len(text1)) >
+              self.Patch_DeleteThreshold):
+            # The end points match, but the content is unacceptably bad.
+            results[-1] = False
+          else:
+            self.diff_cleanupSemanticLossless(diffs)
+            index1 = 0
+            for (op, data) in patch.diffs:
+              if op != self.DIFF_EQUAL:
+                index2 = self.diff_xIndex(diffs, index1)
+              if op == self.DIFF_INSERT:  # Insertion
+                text = text[:start_loc + index2] + data + text[start_loc +
+                                                               index2:]
+              elif op == self.DIFF_DELETE:  # Deletion
+                text = text[:start_loc + index2] + text[start_loc +
+                    self.diff_xIndex(diffs, index1 + len(data)):]
+              if op != self.DIFF_DELETE:
+                index1 += len(data)
+    # Strip the padding off.
+    text = text[len(nullPadding):-len(nullPadding)]
+    return (text, results)
+
+  def patch_addPadding(self, patches):
+    """Add some padding on text start and end so that edges can match
+    something.  Intended to be called only from within patch_apply.
+
+    Args:
+      patches: Array of Patch objects.
+
+    Returns:
+      The padding string added to each side.
+    """
+    paddingLength = self.Patch_Margin
+    nullPadding = ""
+    for x in xrange(1, paddingLength + 1):
+      nullPadding += chr(x)
+
+    # Bump all the patches forward.
+    for patch in patches:
+      patch.start1 += paddingLength
+      patch.start2 += paddingLength
+
+    # Add some padding on start of first diff.
+    patch = patches[0]
+    diffs = patch.diffs
+    if not diffs or diffs[0][0] != self.DIFF_EQUAL:
+      # Add nullPadding equality.
+      diffs.insert(0, (self.DIFF_EQUAL, nullPadding))
+      patch.start1 -= paddingLength  # Should be 0.
+      patch.start2 -= paddingLength  # Should be 0.
+      patch.length1 += paddingLength
+      patch.length2 += paddingLength
+    elif paddingLength > len(diffs[0][1]):
+      # Grow first equality.
+      extraLength = paddingLength - len(diffs[0][1])
+      newText = nullPadding[len(diffs[0][1]):] + diffs[0][1]
+      diffs[0] = (diffs[0][0], newText)
+      patch.start1 -= extraLength
+      patch.start2 -= extraLength
+      patch.length1 += extraLength
+      patch.length2 += extraLength
+
+    # Add some padding on end of last diff.
+    patch = patches[-1]
+    diffs = patch.diffs
+    if not diffs or diffs[-1][0] != self.DIFF_EQUAL:
+      # Add nullPadding equality.
+      diffs.append((self.DIFF_EQUAL, nullPadding))
+      patch.length1 += paddingLength
+      patch.length2 += paddingLength
+    elif paddingLength > len(diffs[-1][1]):
+      # Grow last equality.
+      extraLength = paddingLength - len(diffs[-1][1])
+      newText = diffs[-1][1] + nullPadding[:extraLength]
+      diffs[-1] = (diffs[-1][0], newText)
+      patch.length1 += extraLength
+      patch.length2 += extraLength
+
+    return nullPadding
+
+  def patch_splitMax(self, patches):
+    """Look through the patches and break up any which are longer than the
+    maximum limit of the match algorithm.
+    Intended to be called only from within patch_apply.
+
+    Args:
+      patches: Array of Patch objects.
+    """
+    patch_size = self.Match_MaxBits
+    if patch_size == 0:
+      # Python has the option of not splitting strings due to its ability
+      # to handle integers of arbitrary precision.
+      return
+    for x in xrange(len(patches)):
+      if patches[x].length1 <= patch_size:
+        continue
+      bigpatch = patches[x]
+      # Remove the big old patch.
+      del patches[x]
+      x -= 1
+      start1 = bigpatch.start1
+      start2 = bigpatch.start2
+      precontext = ''
+      while len(bigpatch.diffs) != 0:
+        # Create one of several smaller patches.
+        patch = patch_obj()
+        empty = True
+        patch.start1 = start1 - len(precontext)
+        patch.start2 = start2 - len(precontext)
+        if precontext:
+          patch.length1 = patch.length2 = len(precontext)
+          patch.diffs.append((self.DIFF_EQUAL, precontext))
+
+        while (len(bigpatch.diffs) != 0 and
+               patch.length1 < patch_size - self.Patch_Margin):
+          (diff_type, diff_text) = bigpatch.diffs[0]
+          if diff_type == self.DIFF_INSERT:
+            # Insertions are harmless.
+            patch.length2 += len(diff_text)
+            start2 += len(diff_text)
+            patch.diffs.append(bigpatch.diffs.pop(0))
+            empty = False
+          elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and
+              patch.diffs[0][0] == self.DIFF_EQUAL and
+              len(diff_text) > 2 * patch_size):
+            # This is a large deletion.  Let it pass in one chunk.
+            patch.length1 += len(diff_text)
+            start1 += len(diff_text)
+            empty = False
+            patch.diffs.append((diff_type, diff_text))
+            del bigpatch.diffs[0]
+          else:
+            # Deletion or equality.  Only take as much as we can stomach.
+            diff_text = diff_text[:patch_size - patch.length1 -
+                                  self.Patch_Margin]
+            patch.length1 += len(diff_text)
+            start1 += len(diff_text)
+            if diff_type == self.DIFF_EQUAL:
+              patch.length2 += len(diff_text)
+              start2 += len(diff_text)
+            else:
+              empty = False
+
+            patch.diffs.append((diff_type, diff_text))
+            if diff_text == bigpatch.diffs[0][1]:
+              del bigpatch.diffs[0]
+            else:
+              bigpatch.diffs[0] = (bigpatch.diffs[0][0],
+                                   bigpatch.diffs[0][1][len(diff_text):])
+
+        # Compute the head context for the next patch.
+        precontext = self.diff_text2(patch.diffs)
+        precontext = precontext[-self.Patch_Margin:]
+        # Append the end context for this patch.
+        postcontext = self.diff_text1(bigpatch.diffs)[:self.Patch_Margin]
+        if postcontext:
+          patch.length1 += len(postcontext)
+          patch.length2 += len(postcontext)
+          if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL:
+            patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] +
+                               postcontext)
+          else:
+            patch.diffs.append((self.DIFF_EQUAL, postcontext))
+
+        if not empty:
+          x += 1
+          patches.insert(x, patch)
+
+  def patch_toText(self, patches):
+    """Take a list of patches and return a textual representation.
+
+    Args:
+      patches: Array of Patch objects.
+
+    Returns:
+      Text representation of patches.
+    """
+    text = []
+    for patch in patches:
+      text.append(str(patch))
+    return "".join(text)
+
+  def patch_fromText(self, textline):
+    """Parse a textual representation of patches and return a list of patch
+    objects.
+
+    Args:
+      textline: Text representation of patches.
+
+    Returns:
+      Array of Patch objects.
+
+    Raises:
+      ValueError: If invalid input.
+    """
+    if type(textline) == unicode:
+      # Patches should be composed of a subset of ascii chars, Unicode not
+      # required.  If this encode raises UnicodeEncodeError, patch is invalid.
+      textline = textline.encode("ascii")
+    patches = []
+    if not textline:
+      return patches
+    text = textline.split('\n')
+    while len(text) != 0:
+      m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0])
+      if not m:
+        raise ValueError("Invalid patch string: " + text[0])
+      patch = patch_obj()
+      patches.append(patch)
+      patch.start1 = int(m.group(1))
+      if m.group(2) == '':
+        patch.start1 -= 1
+        patch.length1 = 1
+      elif m.group(2) == '0':
+        patch.length1 = 0
+      else:
+        patch.start1 -= 1
+        patch.length1 = int(m.group(2))
+
+      patch.start2 = int(m.group(3))
+      if m.group(4) == '':
+        patch.start2 -= 1
+        patch.length2 = 1
+      elif m.group(4) == '0':
+        patch.length2 = 0
+      else:
+        patch.start2 -= 1
+        patch.length2 = int(m.group(4))
+
+      del text[0]
+
+      while len(text) != 0:
+        if text[0]:
+          sign = text[0][0]
+        else:
+          sign = ''
+        line = urllib.unquote(text[0][1:])
+        line = line.decode("utf-8")
+        if sign == '+':
+          # Insertion.
+          patch.diffs.append((self.DIFF_INSERT, line))
+        elif sign == '-':
+          # Deletion.
+          patch.diffs.append((self.DIFF_DELETE, line))
+        elif sign == ' ':
+          # Minor equality.
+          patch.diffs.append((self.DIFF_EQUAL, line))
+        elif sign == '@':
+          # Start of next patch.
+          break
+        elif sign == '':
+          # Blank line?  Whatever.
+          pass
+        else:
+          # WTF?
+          raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line))
+        del text[0]
+    return patches
+
+
+class patch_obj:
+  """Class representing one patch operation.
+  """
+
+  def __init__(self):
+    """Initializes with an empty list of diffs.
+    """
+    self.diffs = []
+    self.start1 = None
+    self.start2 = None
+    self.length1 = 0
+    self.length2 = 0
+
+  def __str__(self):
+    """Emmulate GNU diff's format.
+    Header: @@ -382,8 +481,9 @@
+    Indicies are printed as 1-based, not 0-based.
+
+    Returns:
+      The GNU diff string.
+    """
+    if self.length1 == 0:
+      coords1 = str(self.start1) + ",0"
+    elif self.length1 == 1:
+      coords1 = str(self.start1 + 1)
+    else:
+      coords1 = str(self.start1 + 1) + "," + str(self.length1)
+    if self.length2 == 0:
+      coords2 = str(self.start2) + ",0"
+    elif self.length2 == 1:
+      coords2 = str(self.start2 + 1)
+    else:
+      coords2 = str(self.start2 + 1) + "," + str(self.length2)
+    text = ["@@ -", coords1, " +", coords2, " @@\n"]
+    # Escape the body of the patch with %xx notation.
+    for (op, data) in self.diffs:
+      if op == diff_match_patch.DIFF_INSERT:
+        text.append("+")
+      elif op == diff_match_patch.DIFF_DELETE:
+        text.append("-")
+      elif op == diff_match_patch.DIFF_EQUAL:
+        text.append(" ")
+      # High ascii will raise UnicodeDecodeError.  Use Unicode instead.
+      data = data.encode("utf-8")
+      text.append(urllib.quote(data, "!~*'();/?:@&=+$,# ") + "\n")
+    return "".join(text)
  No newline at end of file

rhodecode/lib/middleware/error_handling.py

@@ -0,0 +1,99 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+import logging
+from pyramid import httpexceptions
+from pyramid.httpexceptions import HTTPError, HTTPInternalServerError
+from pyramid.threadlocal import get_current_request
+
+from rhodecode.lib.exceptions import VCSServerUnavailable
+from rhodecode.lib.vcs.exceptions import VCSCommunicationError
+
+
+log = logging.getLogger(__name__)
+
+
+class PylonsErrorHandlingMiddleware(object):
+    """
+    This middleware is wrapped around the old pylons application to catch
+    errors and invoke our error handling view to return a proper error page.
+    """
+    def __init__(self, app, error_view, reraise=False):
+        self.app = app
+        self.error_view = error_view
+        self._reraise = reraise
+
+    def __call__(self, environ, start_response):
+        # We need to use the pyramid request here instead of creating a custom
+        # instance from the environ because this request maybe passed to the
+        # error handler view which is a pyramid view and expects a pyramid
+        # request which has been processed by the pyramid router.
+        request = get_current_request()
+
+        response = self.handle_request(request)
+        return response(environ, start_response)
+
+    def is_http_error(self, response):
+        # webob type error responses
+        return (400 <= response.status_int <= 599)
+
+    def reraise(self):
+        return self._reraise
+
+    def handle_request(self, request):
+        """
+        Calls the underlying WSGI app (typically the old RhodeCode pylons app)
+        and returns the response if no error happened. In case of an error it
+        invokes the error handling view to return a proper error page as
+        response.
+
+        - old webob type exceptions get converted to pyramid exceptions
+        - pyramid exceptions are passed to the error handler view
+        """
+        try:
+            response = request.get_response(self.app)
+            if self.is_http_error(response):
+                response = webob_to_pyramid_http_response(response)
+                return self.error_view(response, request)
+        except HTTPError as e:  # pyramid type exceptions
+            return self.error_view(e, request)
+        except Exception as e:
+            log.exception(e)
+
+            if self.reraise():
+                raise
+
+            if isinstance(e, VCSCommunicationError):
+                return self.error_view(VCSServerUnavailable(), request)
+
+            return self.error_view(HTTPInternalServerError(), request)
+
+        return response
+
+
+def webob_to_pyramid_http_response(webob_response):
+    ResponseClass = httpexceptions.status_map[webob_response.status_int]
+    pyramid_response = ResponseClass(webob_response.status)
+    pyramid_response.status = webob_response.status
+    pyramid_response.headers.update(webob_response.headers)
+    if pyramid_response.headers['content-type'] == 'text/html':
+        pyramid_response.headers['content-type'] = 'text/html; charset=UTF-8'
+    return pyramid_response

rhodecode/lib/system_info.py

@@ -0,0 +1,640 b''
+import os
+import sys
+import time
+import platform
+import pkg_resources
+import logging
+import string
+
+
+log = logging.getLogger(__name__)
+
+
+psutil = None
+
+try:
+    # cygwin cannot have yet psutil support.
+    import psutil as psutil
+except ImportError:
+    pass
+
+
+_NA = 'NOT AVAILABLE'
+
+STATE_OK = 'ok'
+STATE_ERR = 'error'
+STATE_WARN = 'warning'
+
+STATE_OK_DEFAULT = {'message': '', 'type': STATE_OK}
+
+
+# HELPERS
+def percentage(part, whole):
+    whole = float(whole)
+    if whole > 0:
+        return round(100 * float(part) / whole, 1)
+    return 0.0
+
+
+def get_storage_size(storage_path):
+    sizes = []
+    for file_ in os.listdir(storage_path):
+        storage_file = os.path.join(storage_path, file_)
+        if os.path.isfile(storage_file):
+            try:
+                sizes.append(os.path.getsize(storage_file))
+            except OSError:
+                log.exception('Failed to get size of storage file %s',
+                              storage_file)
+                pass
+
+    return sum(sizes)
+
+
+class SysInfoRes(object):
+    def __init__(self, value, state=STATE_OK_DEFAULT, human_value=None):
+        self.value = value
+        self.state = state
+        self.human_value = human_value or value
+
+    def __json__(self):
+        return {
+            'value': self.value,
+            'state': self.state,
+            'human_value': self.human_value,
+        }
+
+    def __str__(self):
+        return '<SysInfoRes({})>'.format(self.__json__())
+
+
+class SysInfo(object):
+
+    def __init__(self, func_name, **kwargs):
+        self.func_name = func_name
+        self.value = _NA
+        self.state = None
+        self.kwargs = kwargs or {}
+
+    def __call__(self):
+        computed = self.compute(**self.kwargs)
+        if not isinstance(computed, SysInfoRes):
+            raise ValueError(
+                'computed value for {} is not instance of '
+                '{}, got {} instead'.format(
+                    self.func_name, SysInfoRes, type(computed)))
+        return computed.__json__()
+
+    def __str__(self):
+        return '<SysInfo({})>'.format(self.func_name)
+
+    def compute(self, **kwargs):
+        return self.func_name(**kwargs)
+
+
+# SysInfo functions
+def python_info():
+    value = dict(version=' '.join(platform._sys_version()),
+                 executable=sys.executable)
+    return SysInfoRes(value=value)
+
+
+def py_modules():
+    mods = dict([(p.project_name, p.version)
+                 for p in pkg_resources.working_set])
+    value = sorted(mods.items(), key=lambda k: k[0].lower())
+    return SysInfoRes(value=value)
+
+
+def platform_type():
+    from rhodecode.lib.utils import safe_unicode, generate_platform_uuid
+
+    value = dict(
+        name=safe_unicode(platform.platform()),
+        uuid=generate_platform_uuid()
+    )
+    return SysInfoRes(value=value)
+
+
+def uptime():
+    from rhodecode.lib.helpers import age, time_to_datetime
+
+    value = dict(boot_time=0, uptime=0, text='')
+    state = STATE_OK_DEFAULT
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    boot_time = psutil.boot_time()
+    value['boot_time'] = boot_time
+    value['uptime'] = time.time() - boot_time
+
+    human_value = value.copy()
+    human_value['boot_time'] = time_to_datetime(boot_time)
+    human_value['uptime'] = age(time_to_datetime(boot_time), show_suffix=False)
+    human_value['text'] = 'Server started {}'.format(
+        age(time_to_datetime(boot_time)))
+
+    return SysInfoRes(value=value, human_value=human_value)
+
+
+def memory():
+    from rhodecode.lib.helpers import format_byte_size_binary
+    value = dict(available=0, used=0, used_real=0, cached=0, percent=0,
+                 percent_used=0, free=0, inactive=0, active=0, shared=0,
+                 total=0, buffers=0, text='')
+
+    state = STATE_OK_DEFAULT
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    value.update(dict(psutil.virtual_memory()._asdict()))
+    value['used_real'] = value['total'] - value['available']
+    value['percent_used'] = psutil._common.usage_percent(
+        value['used_real'], value['total'], 1)
+
+    human_value = value.copy()
+    human_value['text'] = '%s/%s, %s%% used' % (
+        format_byte_size_binary(value['used_real']),
+        format_byte_size_binary(value['total']),
+        value['percent_used'],)
+
+    keys = value.keys()[::]
+    keys.pop(keys.index('percent'))
+    keys.pop(keys.index('percent_used'))
+    keys.pop(keys.index('text'))
+    for k in keys:
+        human_value[k] = format_byte_size_binary(value[k])
+
+    if state['type'] == STATE_OK and value['percent_used'] > 90:
+        msg = 'Critical: your available RAM memory is very low.'
+        state = {'message': msg, 'type': STATE_ERR}
+
+    elif state['type'] == STATE_OK and value['percent_used'] > 70:
+        msg = 'Warning: your available RAM memory is running low.'
+        state = {'message': msg, 'type': STATE_WARN}
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def machine_load():
+    value = {'1_min': _NA, '5_min': _NA, '15_min': _NA, 'text': ''}
+    state = STATE_OK_DEFAULT
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    # load averages
+    if hasattr(psutil.os, 'getloadavg'):
+        value.update(dict(
+            zip(['1_min', '5_min', '15_min'], psutil.os.getloadavg())))
+
+    human_value = value.copy()
+    human_value['text'] = '1min: {}, 5min: {}, 15min: {}'.format(
+        value['1_min'], value['5_min'], value['15_min'])
+
+    if state['type'] == STATE_OK and value['15_min'] > 5:
+        msg = 'Warning: your machine load is very high.'
+        state = {'message': msg, 'type': STATE_WARN}
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def cpu():
+    value = 0
+    state = STATE_OK_DEFAULT
+
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    value = psutil.cpu_percent(0.5)
+    human_value = '{} %'.format(value)
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def storage():
+    from rhodecode.lib.helpers import format_byte_size_binary
+    from rhodecode.model.settings import VcsSettingsModel
+    path = VcsSettingsModel().get_repos_location()
+
+    value = dict(percent=0, used=0, total=0, path=path, text='')
+    state = STATE_OK_DEFAULT
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    try:
+        value.update(dict(psutil.disk_usage(path)._asdict()))
+    except Exception as e:
+        log.exception('Failed to fetch disk info')
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    human_value = value.copy()
+    human_value['used'] = format_byte_size_binary(value['used'])
+    human_value['total'] = format_byte_size_binary(value['total'])
+    human_value['text'] = "{}/{}, {}% used".format(
+        format_byte_size_binary(value['used']),
+        format_byte_size_binary(value['total']),
+        value['percent'])
+
+    if state['type'] == STATE_OK and value['percent'] > 90:
+        msg = 'Critical: your disk space is very low.'
+        state = {'message': msg, 'type': STATE_ERR}
+
+    elif state['type'] == STATE_OK and value['percent'] > 70:
+        msg = 'Warning: your disk space is running low.'
+        state = {'message': msg, 'type': STATE_WARN}
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def storage_inodes():
+    from rhodecode.model.settings import VcsSettingsModel
+    path = VcsSettingsModel().get_repos_location()
+
+    value = dict(percent=0, free=0, used=0, total=0, path=path, text='')
+    state = STATE_OK_DEFAULT
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    try:
+        i_stat = os.statvfs(path)
+
+        value['used'] = i_stat.f_ffree
+        value['free'] = i_stat.f_favail
+        value['total'] = i_stat.f_files
+        value['percent'] = percentage(value['used'], value['total'])
+    except Exception as e:
+        log.exception('Failed to fetch disk inodes info')
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    human_value = value.copy()
+    human_value['text'] = "{}/{}, {}% used".format(
+        value['used'], value['total'], value['percent'])
+
+    if state['type'] == STATE_OK and value['percent'] > 90:
+        msg = 'Critical: your disk free inodes are very low.'
+        state = {'message': msg, 'type': STATE_ERR}
+
+    elif state['type'] == STATE_OK and value['percent'] > 70:
+        msg = 'Warning: your disk free inodes are running low.'
+        state = {'message': msg, 'type': STATE_WARN}
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def storage_archives():
+    import rhodecode
+    from rhodecode.lib.utils import safe_str
+    from rhodecode.lib.helpers import format_byte_size_binary
+
+    msg = 'Enable this by setting ' \
+          'archive_cache_dir=/path/to/cache option in the .ini file'
+    path = safe_str(rhodecode.CONFIG.get('archive_cache_dir', msg))
+
+    value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
+    state = STATE_OK_DEFAULT
+    try:
+        items_count = 0
+        used = 0
+        for root, dirs, files in os.walk(path):
+            if root == path:
+                items_count = len(files)
+
+            for f in files:
+                try:
+                    used += os.path.getsize(os.path.join(root, f))
+                except OSError:
+                    pass
+        value.update({
+            'percent': 100,
+            'used': used,
+            'total': used,
+            'items': items_count
+        })
+
+    except Exception as e:
+        log.exception('failed to fetch archive cache storage')
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    human_value = value.copy()
+    human_value['used'] = format_byte_size_binary(value['used'])
+    human_value['total'] = format_byte_size_binary(value['total'])
+    human_value['text'] = "{} ({} items)".format(
+        human_value['used'], value['items'])
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def storage_gist():
+    from rhodecode.model.gist import GIST_STORE_LOC
+    from rhodecode.model.settings import VcsSettingsModel
+    from rhodecode.lib.utils import safe_str
+    from rhodecode.lib.helpers import format_byte_size_binary
+    path = safe_str(os.path.join(
+        VcsSettingsModel().get_repos_location(), GIST_STORE_LOC))
+
+    # gist storage
+    value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
+    state = STATE_OK_DEFAULT
+
+    try:
+        items_count = 0
+        used = 0
+        for root, dirs, files in os.walk(path):
+            if root == path:
+                items_count = len(dirs)
+
+            for f in files:
+                try:
+                    used += os.path.getsize(os.path.join(root, f))
+                except OSError:
+                    pass
+        value.update({
+            'percent': 100,
+            'used': used,
+            'total': used,
+            'items': items_count
+        })
+    except Exception as e:
+        log.exception('failed to fetch gist storage items')
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    human_value = value.copy()
+    human_value['used'] = format_byte_size_binary(value['used'])
+    human_value['total'] = format_byte_size_binary(value['total'])
+    human_value['text'] = "{} ({} items)".format(
+        human_value['used'], value['items'])
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def storage_temp():
+    import tempfile
+    from rhodecode.lib.helpers import format_byte_size_binary
+
+    path = tempfile.gettempdir()
+    value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
+    state = STATE_OK_DEFAULT
+
+    if not psutil:
+        return SysInfoRes(value=value, state=state)
+
+    try:
+        value.update(dict(psutil.disk_usage(path)._asdict()))
+    except Exception as e:
+        log.exception('Failed to fetch temp dir info')
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    human_value = value.copy()
+    human_value['used'] = format_byte_size_binary(value['used'])
+    human_value['total'] = format_byte_size_binary(value['total'])
+    human_value['text'] = "{}/{}, {}% used".format(
+        format_byte_size_binary(value['used']),
+        format_byte_size_binary(value['total']),
+        value['percent'])
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def search_info():
+    import rhodecode
+    from rhodecode.lib.index import searcher_from_config
+
+    backend = rhodecode.CONFIG.get('search.module', '')
+    location = rhodecode.CONFIG.get('search.location', '')
+
+    try:
+        searcher = searcher_from_config(rhodecode.CONFIG)
+        searcher = searcher.__class__.__name__
+    except Exception:
+        searcher = None
+
+    value = dict(
+        backend=backend, searcher=searcher, location=location, text='')
+    state = STATE_OK_DEFAULT
+
+    human_value = value.copy()
+    human_value['text'] = "backend:`{}`".format(human_value['backend'])
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def git_info():
+    from rhodecode.lib.vcs.backends import git
+    state = STATE_OK_DEFAULT
+    value = human_value = ''
+    try:
+        value = git.discover_git_version(raise_on_exc=True)
+        human_value = 'version reported from VCSServer: {}'.format(value)
+    except Exception as e:
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def hg_info():
+    from rhodecode.lib.vcs.backends import hg
+    state = STATE_OK_DEFAULT
+    value = human_value = ''
+    try:
+        value = hg.discover_hg_version(raise_on_exc=True)
+        human_value = 'version reported from VCSServer: {}'.format(value)
+    except Exception as e:
+        state = {'message': str(e), 'type': STATE_ERR}
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def svn_info():
+    from rhodecode.lib.vcs.backends import svn
+    state = STATE_OK_DEFAULT
+    value = human_value = ''
+    try:
+        value = svn.discover_svn_version(raise_on_exc=True)
+        human_value = 'version reported from VCSServer: {}'.format(value)
+    except Exception as e:
+        state = {'message': str(e), 'type': STATE_ERR}
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def vcs_backends():
+    import rhodecode
+    value = map(
+        string.strip, rhodecode.CONFIG.get('vcs.backends', '').split(','))
+    human_value = 'Enabled backends in order: {}'.format(','.join(value))
+    return SysInfoRes(value=value, human_value=human_value)
+
+
+def vcs_server():
+    import rhodecode
+    from rhodecode.lib.vcs.backends import get_vcsserver_version
+
+    server_url = rhodecode.CONFIG.get('vcs.server')
+    enabled = rhodecode.CONFIG.get('vcs.server.enable')
+    protocol = rhodecode.CONFIG.get('vcs.server.protocol')
+    state = STATE_OK_DEFAULT
+    version = None
+
+    try:
+        version = get_vcsserver_version()
+        connection = 'connected'
+    except Exception as e:
+        connection = 'failed'
+        state = {'message': str(e), 'type': STATE_ERR}
+
+    value = dict(
+        url=server_url,
+        enabled=enabled,
+        protocol=protocol,
+        connection=connection,
+        version=version,
+        text='',
+    )
+
+    human_value = value.copy()
+    human_value['text'] = \
+        '{url}@ver:{ver} via {mode} mode, connection:{conn}'.format(
+            url=server_url, ver=version, mode=protocol, conn=connection)
+
+    return SysInfoRes(value=value, state=state, human_value=human_value)
+
+
+def rhodecode_app_info():
+    import rhodecode
+    edition = rhodecode.CONFIG.get('rhodecode.edition')
+
+    value = dict(
+        rhodecode_version=rhodecode.__version__,
+        rhodecode_lib_path=os.path.abspath(rhodecode.__file__),
+        text=''
+    )
+    human_value = value.copy()
+    human_value['text'] = 'RhodeCode {edition}, version {ver}'.format(
+        edition=edition, ver=value['rhodecode_version']
+    )
+    return SysInfoRes(value=value, human_value=human_value)
+
+
+def rhodecode_config():
+    import rhodecode
+    path = rhodecode.CONFIG.get('__file__')
+    rhodecode_ini_safe = rhodecode.CONFIG.copy()
+
+    blacklist = [
+        'rhodecode_license_key',
+        'routes.map',
+        'pylons.h',
+        'pylons.app_globals',
+        'pylons.environ_config',
+        'sqlalchemy.db1.url',
+        'channelstream.secret',
+        'beaker.session.secret',
+        'rhodecode.encrypted_values.secret',
+        'rhodecode_auth_github_consumer_key',
+        'rhodecode_auth_github_consumer_secret',
+        'rhodecode_auth_google_consumer_key',
+        'rhodecode_auth_google_consumer_secret',
+        'rhodecode_auth_bitbucket_consumer_secret',
+        'rhodecode_auth_bitbucket_consumer_key',
+        'rhodecode_auth_twitter_consumer_secret',
+        'rhodecode_auth_twitter_consumer_key',
+
+        'rhodecode_auth_twitter_secret',
+        'rhodecode_auth_github_secret',
+        'rhodecode_auth_google_secret',
+        'rhodecode_auth_bitbucket_secret',
+
+        'appenlight.api_key',
+        ('app_conf', 'sqlalchemy.db1.url')
+    ]
+    for k in blacklist:
+        if isinstance(k, tuple):
+            section, key = k
+            if section in rhodecode_ini_safe:
+                rhodecode_ini_safe[section] = '**OBFUSCATED**'
+        else:
+            rhodecode_ini_safe.pop(k, None)
+
+    # TODO: maybe put some CONFIG checks here ?
+    return SysInfoRes(value={'config': rhodecode_ini_safe, 'path': path})
+
+
+def database_info():
+    import rhodecode
+    from sqlalchemy.engine import url as engine_url
+    from rhodecode.model.meta import Base as sql_base, Session
+    from rhodecode.model.db import DbMigrateVersion
+
+    state = STATE_OK_DEFAULT
+
+    db_migrate = DbMigrateVersion.query().filter(
+        DbMigrateVersion.repository_id == 'rhodecode_db_migrations').one()
+
+    db_url_obj = engine_url.make_url(rhodecode.CONFIG['sqlalchemy.db1.url'])
+
+    try:
+        engine = sql_base.metadata.bind
+        db_server_info = engine.dialect._get_server_version_info(
+            Session.connection(bind=engine))
+        db_version = '.'.join(map(str, db_server_info))
+    except Exception:
+        log.exception('failed to fetch db version')
+        db_version = 'UNKNOWN'
+
+    db_info = dict(
+        migrate_version=db_migrate.version,
+        type=db_url_obj.get_backend_name(),
+        version=db_version,
+        url=repr(db_url_obj)
+    )
+
+    human_value = db_info.copy()
+    human_value['url'] = "{} @ migration version: {}".format(
+        db_info['url'], db_info['migrate_version'])
+    human_value['version'] = "{} {}".format(db_info['type'], db_info['version'])
+    return SysInfoRes(value=db_info, state=state, human_value=human_value)
+
+
+def server_info(environ):
+    import rhodecode
+    from rhodecode.lib.base import get_server_ip_addr, get_server_port
+
+    value = {
+        'server_ip': '%s:%s' % (
+            get_server_ip_addr(environ, log_errors=False),
+            get_server_port(environ)
+        ),
+        'server_id': rhodecode.CONFIG.get('instance_id'),
+    }
+    return SysInfoRes(value=value)
+
+
+def get_system_info(environ):
+    environ = environ or {}
+    return {
+        'rhodecode_app': SysInfo(rhodecode_app_info)(),
+        'rhodecode_config': SysInfo(rhodecode_config)(),
+        'python': SysInfo(python_info)(),
+        'py_modules': SysInfo(py_modules)(),
+
+        'platform': SysInfo(platform_type)(),
+        'server': SysInfo(server_info, environ=environ)(),
+        'database': SysInfo(database_info)(),
+
+        'storage': SysInfo(storage)(),
+        'storage_inodes': SysInfo(storage_inodes)(),
+        'storage_archive': SysInfo(storage_archives)(),
+        'storage_gist': SysInfo(storage_gist)(),
+        'storage_temp': SysInfo(storage_temp)(),
+
+        'search': SysInfo(search_info)(),
+
+        'uptime': SysInfo(uptime)(),
+        'load': SysInfo(machine_load)(),
+        'cpu': SysInfo(cpu)(),
+        'memory': SysInfo(memory)(),
+
+        'vcs_backends': SysInfo(vcs_backends)(),
+        'vcs_server': SysInfo(vcs_server)(),
+
+        'git': SysInfo(git_info)(),
+        'hg': SysInfo(hg_info)(),
+        'svn': SysInfo(svn_info)(),
+    }

rhodecode/login/tests/test_register_captcha.py

@@ -0,0 +1,128 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+import mock
+import pytest
+
+from rhodecode.config.routing import ADMIN_PREFIX
+from rhodecode.login.views import LoginView, CaptchaData
+from rhodecode.model.settings import SettingsModel
+from rhodecode.tests.utils import AssertResponse
+
+
+class RhodeCodeSetting(object):
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    def __enter__(self):
+        from rhodecode.model.settings import SettingsModel
+        model = SettingsModel()
+        self.old_setting = model.get_setting_by_name(self.name)
+        model.create_or_update_setting(name=self.name, val=self.value)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        model = SettingsModel()
+        if self.old_setting:
+            model.create_or_update_setting(
+                name=self.name, val=self.old_setting.app_settings_value)
+        else:
+            model.create_or_update_setting(name=self.name)
+
+
+class TestRegisterCaptcha(object):
+
+    @pytest.mark.parametrize('private_key, public_key, expected', [
+        ('',        '',       CaptchaData(False, '',        '')),
+        ('',        'pubkey', CaptchaData(False, '',        'pubkey')),
+        ('privkey', '',       CaptchaData(True,  'privkey', '')),
+        ('privkey', 'pubkey', CaptchaData(True,  'privkey', 'pubkey')),
+    ])
+    def test_get_captcha_data(self, private_key, public_key, expected, db):
+        login_view = LoginView(mock.Mock(), mock.Mock())
+        with RhodeCodeSetting('captcha_private_key', private_key):
+            with RhodeCodeSetting('captcha_public_key', public_key):
+                captcha = login_view._get_captcha_data()
+                assert captcha == expected
+
+    @pytest.mark.parametrize('active', [False, True])
+    @mock.patch.object(LoginView, '_get_captcha_data')
+    def test_private_key_does_not_leak_to_html(
+            self, m_get_captcha_data, active, app):
+        captcha = CaptchaData(
+            active=active, private_key='PRIVATE_KEY', public_key='PUBLIC_KEY')
+        m_get_captcha_data.return_value = captcha
+
+        response = app.get(ADMIN_PREFIX + '/register')
+        assert 'PRIVATE_KEY' not in response
+
+    @pytest.mark.parametrize('active', [False, True])
+    @mock.patch.object(LoginView, '_get_captcha_data')
+    def test_register_view_renders_captcha(
+            self, m_get_captcha_data, active, app):
+        captcha = CaptchaData(
+            active=active, private_key='PRIVATE_KEY', public_key='PUBLIC_KEY')
+        m_get_captcha_data.return_value = captcha
+
+        response = app.get(ADMIN_PREFIX + '/register')
+
+        assertr = AssertResponse(response)
+        if active:
+            assertr.one_element_exists('#recaptcha_field')
+        else:
+            assertr.no_element_exists('#recaptcha_field')
+
+    @pytest.mark.parametrize('valid', [False, True])
+    @mock.patch('rhodecode.login.views.submit')
+    @mock.patch.object(LoginView, '_get_captcha_data')
+    def test_register_with_active_captcha(
+            self, m_get_captcha_data, m_submit, valid, app, csrf_token):
+        captcha = CaptchaData(
+            active=True, private_key='PRIVATE_KEY', public_key='PUBLIC_KEY')
+        m_get_captcha_data.return_value = captcha
+        m_response = mock.Mock()
+        m_response.is_valid = valid
+        m_submit.return_value = m_response
+
+        params = {
+            'csrf_token': csrf_token,
+            'email': '[e-mail]',
+            'firstname': 'pytest-firstname',
+            'lastname': 'pytest-lastname',
+            'password': 'secret',
+            'password_confirmation': 'secret',
+            'username': 'pytest',
+        }
+        response = app.post(ADMIN_PREFIX + '/register', params=params)
+
+        if valid:
+            # If we provided a valid captcha input we expect a successful
+            # registration and redirect to the login page.
+            assert response.status_int == 302
+            assert 'location' in response.headers
+            assert ADMIN_PREFIX + '/login' in response.headers['location']
+        else:
+            # If captche input is invalid we expect to stay on the registration
+            # page with an error message displayed.
+            assertr = AssertResponse(response)
+            assert response.status_int == 200
+            assertr.one_element_exists('#recaptcha_field ~ span.error-message')

rhodecode/public/js/src/components/rhodecode-favicon/rhodecode-favicon.html

@@ -0,0 +1,7 b''
+<link rel="import" href="../../../../../../bower_components/polymer/polymer.html">
+
+<dom-module id="rhodecode-favicon">
+    <template>
+    </template>
+    <script src="rhodecode-favicon.js"></script>
+</dom-module>

rhodecode/public/js/src/components/rhodecode-favicon/rhodecode-favicon.js

@@ -0,0 +1,20 b''
+Polymer({
+    is: 'rhodecode-favicon',
+    properties: {
+        favicon: Object,
+        counter: {
+            type: Number,
+            observer: '_handleCounter'
+        }
+    },
+
+    ready: function () {
+        this.favicon = new Favico({
+            type: 'rectangle',
+            animation: 'none'
+        });
+    },
+    _handleCounter: function (newVal, oldVal) {
+        this.favicon.badge(this.counter);
+    }
+});

rhodecode/public/js/src/components/rhodecode-legacy-js/rhodecode-legacy-js.html

@@ -0,0 +1,7 b''
+<link rel="import" href="../../../../../../bower_components/polymer/polymer.html">
+<dom-module id="rhodecode-legacy-js">
+    <template>
+        <script src="../../../scripts.js"></script>
+    </template>
+    <script src="rhodecode-legacy-js.js"></script>
+</dom-module>

rhodecode/public/js/src/components/rhodecode-legacy-js/rhodecode-legacy-js.js

@@ -0,0 +1,3 b''
+Polymer({
+    is: 'rhodecode-legacy-js',
+});

rhodecode/public/js/src/i18n_messages.js

@@ -0,0 +1,8 b''
+// special file to catch some of the translation strings NOT extracted by our extraction system
+// we need to fix that, however until now we add here those manual entries to catch them
+
+_gettext('Invite reviewers to this discussion');
+_gettext('Close');
+_gettext('Send');
+_gettext('Switch to chat');
+_gettext('Switch to comment');

rhodecode/svn_support/events.py

@@ -0,0 +1,30 b''
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+from rhodecode.events.base import RhodecodeEvent
+from rhodecode.translation import _
+
+
+class ModDavSvnConfigChange(RhodecodeEvent):
+    """
+    This event will be triggered on every change of the mod dav svn
+    configuration.
+    """
+    name = 'mod-dav-svn-config-change'
+    display_name = _('Configuration for Apaache mad_dav_svn changed.')

rhodecode/templates/codeblocks/diffs.html

@@ -0,0 +1,569 b''
+<%def name="diff_line_anchor(filename, line, type)"><%
+return '%s_%s_%i' % (h.safeid(filename), type, line)
+%></%def>
+
+<%def name="action_class(action)"><%
+    return {
+        '-': 'cb-deletion',
+        '+': 'cb-addition',
+        ' ': 'cb-context',
+        }.get(action, 'cb-empty')
+%></%def>
+
+<%def name="op_class(op_id)"><%
+    return {
+        DEL_FILENODE: 'deletion', # file deleted
+        BIN_FILENODE: 'warning' # binary diff hidden
+    }.get(op_id, 'addition')
+%></%def>
+
+<%def name="link_for(**kw)"><%
+new_args = request.GET.mixed()
+new_args.update(kw)
+return h.url('', **new_args)
+%></%def>
+
+<%def name="render_diffset(diffset, commit=None,
+
+    # collapse all file diff entries when there are more than this amount of files in the diff
+    collapse_when_files_over=20,
+
+    # collapse lines in the diff when more than this amount of lines changed in the file diff
+    lines_changed_limit=500,
+
+    # add a ruler at to the output
+    ruler_at_chars=0,
+
+    # show inline comments
+    use_comments=False,
+
+    # disable new comments
+    disable_new_comments=False,
+
+)">
+
+%if use_comments:
+<div id="cb-comments-inline-container-template" class="js-template">
+  ${inline_comments_container([])}
+</div>
+<div class="js-template" id="cb-comment-inline-form-template">
+    <div class="comment-inline-form ac">
+    %if c.rhodecode_user.username != h.DEFAULT_USER:
+        ${h.form('#', method='get')}
+        <div id="edit-container_{1}" class="clearfix">
+          <div class="comment-title pull-left">
+            ${_('Create a comment on line {1}.')}
+          </div>
+          <div class="comment-help pull-right">
+            ${(_('Comments parsed using %s syntax with %s support.') % (
+                   ('<a href="%s">%s</a>' % (h.url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())),
+                     ('<span  class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))
+                 )
+              )|n
+             }
+          </div>
+              <div style="clear: both"></div>
+              <textarea id="text_{1}" name="text" class="comment-block-ta ac-input"></textarea>
+        </div>
+        <div id="preview-container_{1}" class="clearfix" style="display: none;">
+           <div class="comment-help">
+                ${_('Comment preview')}
+            </div>
+            <div id="preview-box_{1}" class="preview-box"></div>
+        </div>
+        <div class="comment-footer">
+          <div class="action-buttons">
+            <input type="hidden" name="f_path" value="{0}">
+            <input type="hidden" name="line" value="{1}">
+            <button id="preview-btn_{1}" class="btn btn-secondary">${_('Preview')}</button>
+            <button id="edit-btn_{1}" class="btn btn-secondary" style="display: none;">${_('Edit')}</button>
+            ${h.submit('save', _('Comment'), class_='btn btn-success save-inline-form')}
+          </div>
+          <div class="comment-button">
+           <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);">
+            ${_('Cancel')}
+           </button>
+          </div>
+        ${h.end_form()}
+      </div>
+    %else:
+        ${h.form('', class_='inline-form comment-form-login', method='get')}
+        <div class="pull-left">
+            <div class="comment-help pull-right">
+              ${_('You need to be logged in to comment.')} <a href="${h.route_path('login', _query={'came_from': h.url.current()})}">${_('Login now')}</a>
+            </div>
+        </div>
+        <div class="comment-button pull-right">
+         <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);">
+          ${_('Cancel')}
+         </button>
+        </div>
+        <div class="clearfix"></div>
+        ${h.end_form()}
+    %endif
+    </div>
+</div>
+
+%endif
+<%
+collapse_all = len(diffset.files) > collapse_when_files_over
+%>
+
+%if c.diffmode == 'sideside':
+<style>
+.wrapper {
+    max-width: 1600px !important;
+}
+</style>
+%endif
+%if ruler_at_chars:
+<style>
+.diff table.cb .cb-content:after {
+    content: "";
+    border-left: 1px solid blue;
+    position: absolute;
+    top: 0;
+    height: 18px;
+    opacity: .2;
+    z-index: 10;
+    ## +5 to account for diff action (+/-)
+    left: ${ruler_at_chars + 5}ch;
+</style>
+%endif
+<div class="diffset ${disable_new_comments and 'diffset-comments-disabled'}">
+    <div class="diffset-heading ${diffset.limited_diff and 'diffset-heading-warning' or ''}">
+        %if commit:
+            <div class="pull-right">
+                <a class="btn tooltip" title="${_('Browse Files at revision {}').format(commit.raw_id)}" href="${h.url('files_home',repo_name=diffset.repo_name, revision=commit.raw_id, f_path='')}">
+                    ${_('Browse Files')}
+                </a>
+            </div>
+        %endif
+        <h2 class="clearinner">
+        %if commit:
+            <a class="tooltip revision" title="${h.tooltip(commit.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=commit.raw_id)}">${'r%s:%s' % (commit.revision,h.short_id(commit.raw_id))}</a> -
+            ${h.age_component(commit.date)} -
+        %endif
+    %if diffset.limited_diff:
+    ${_('The requested commit is too big and content was truncated.')}
+
+        ${ungettext('%(num)s file changed.', '%(num)s files changed.', diffset.changed_files) % {'num': diffset.changed_files}}
+        <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
+    %else:
+        ${ungettext('%(num)s file changed: %(linesadd)s inserted, ''%(linesdel)s deleted',
+                    '%(num)s files changed: %(linesadd)s inserted, %(linesdel)s deleted', diffset.changed_files) % {'num': diffset.changed_files, 'linesadd': diffset.lines_added, 'linesdel': diffset.lines_deleted}}
+    %endif
+        </h2>
+    </div>
+
+    %if not diffset.files:
+        <p class="empty_data">${_('No files')}</p>
+    %endif
+
+    <div class="filediffs">
+    %for i, filediff in enumerate(diffset.files):
+    <%
+    lines_changed = filediff['patch']['stats']['added'] + filediff['patch']['stats']['deleted']
+    over_lines_changed_limit = lines_changed > lines_changed_limit
+    %>
+        <input ${collapse_all and 'checked' or ''} class="filediff-collapse-state" id="filediff-collapse-${id(filediff)}" type="checkbox">
+        <div
+            class="filediff"
+            data-f-path="${filediff['patch']['filename']}"
+            id="a_${h.FID('', filediff['patch']['filename'])}">
+            <label for="filediff-collapse-${id(filediff)}" class="filediff-heading">
+                <div class="filediff-collapse-indicator"></div>
+                ${diff_ops(filediff)}
+            </label>
+            ${diff_menu(filediff, use_comments=use_comments)}
+            <table class="cb cb-diff-${c.diffmode} code-highlight ${over_lines_changed_limit and 'cb-collapsed' or ''}">
+        %if not filediff.hunks:
+            %for op_id, op_text in filediff['patch']['stats']['ops'].items():
+                <tr>
+                    <td class="cb-text cb-${op_class(op_id)}" ${c.diffmode == 'unified' and 'colspan=3' or 'colspan=4'}>
+                        %if op_id == DEL_FILENODE:
+                        ${_('File was deleted')}
+                        %elif op_id == BIN_FILENODE:
+                        ${_('Binary file hidden')}
+                        %else:
+                        ${op_text}
+                        %endif
+                    </td>
+                </tr>
+            %endfor
+        %endif
+        %if over_lines_changed_limit:
+                <tr class="cb-warning cb-collapser">
+                    <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=4'}>
+                        ${_('This diff has been collapsed as it changes many lines, (%i lines changed)' % lines_changed)}
+                        <a href="#" class="cb-expand"
+                           onclick="$(this).closest('table').removeClass('cb-collapsed'); return false;">${_('Show them')}
+                        </a>
+                        <a href="#" class="cb-collapse"
+                           onclick="$(this).closest('table').addClass('cb-collapsed'); return false;">${_('Hide them')}
+                        </a>
+                    </td>
+                </tr>
+        %endif
+        %if filediff.patch['is_limited_diff']:
+                <tr class="cb-warning cb-collapser">
+                    <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=4'}>
+                        ${_('The requested commit is too big and content was truncated.')} <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
+                    </td>
+                </tr>
+        %endif
+        %for hunk in filediff.hunks:
+                <tr class="cb-hunk">
+                    <td ${c.diffmode == 'unified' and 'colspan=3' or ''}>
+                        ## TODO: dan: add ajax loading of more context here
+                        ## <a href="#">
+                            <i class="icon-more"></i>
+                        ## </a>
+                    </td>
+                    <td ${c.diffmode == 'sideside' and 'colspan=5' or ''}>
+                        @@
+                        -${hunk.source_start},${hunk.source_length}
+                        +${hunk.target_start},${hunk.target_length}
+                        ${hunk.section_header}
+                    </td>
+                </tr>
+            %if c.diffmode == 'unified':
+                    ${render_hunk_lines_unified(hunk, use_comments=use_comments)}
+            %elif c.diffmode == 'sideside':
+                    ${render_hunk_lines_sideside(hunk, use_comments=use_comments)}
+            %else:
+                <tr class="cb-line">
+                    <td>unknown diff mode</td>
+                </tr>
+            %endif
+        %endfor
+            </table>
+        </div>
+    %endfor
+    </div>
+</div>
+</%def>
+
+<%def name="diff_ops(filediff)">
+<%
+stats = filediff['patch']['stats']
+from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
+    MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE
+%>
+    <span class="pill">
+        %if filediff.source_file_path and filediff.target_file_path:
+            %if filediff.source_file_path != filediff.target_file_path: # file was renamed
+                  <strong>${filediff.target_file_path}</strong> ⬅ <del>${filediff.source_file_path}</del>
+            %else:
+                ## file was modified
+                <strong>${filediff.source_file_path}</strong>
+            %endif
+        %else:
+            %if filediff.source_file_path:
+                ## file was deleted
+                <strong>${filediff.source_file_path}</strong>
+            %else:
+                ## file was added
+                <strong>${filediff.target_file_path}</strong>
+            %endif
+        %endif
+    </span>
+    <span class="pill-group" style="float: left">
+        %if filediff.patch['is_limited_diff']:
+        <span class="pill tooltip" op="limited" title="The stats for this diff are not complete">limited diff</span>
+        %endif
+        %if RENAMED_FILENODE in stats['ops']:
+        <span class="pill" op="renamed">renamed</span>
+        %endif
+
+        %if NEW_FILENODE in stats['ops']:
+        <span class="pill" op="created">created</span>
+            %if filediff['target_mode'].startswith('120'):
+        <span class="pill" op="symlink">symlink</span>
+            %else:
+        <span class="pill" op="mode">${nice_mode(filediff['target_mode'])}</span>
+            %endif
+        %endif
+
+        %if DEL_FILENODE in stats['ops']:
+        <span class="pill" op="removed">removed</span>
+        %endif
+
+        %if CHMOD_FILENODE in stats['ops']:
+        <span class="pill" op="mode">
+            ${nice_mode(filediff['source_mode'])} ➡ ${nice_mode(filediff['target_mode'])}
+        </span>
+        %endif
+    </span>
+
+    <a class="pill filediff-anchor" href="#a_${h.FID('', filediff.patch['filename'])}">¶</a>
+
+    <span class="pill-group" style="float: right">
+        %if BIN_FILENODE in stats['ops']:
+        <span class="pill" op="binary">binary</span>
+            %if MOD_FILENODE in stats['ops']:
+            <span class="pill" op="modified">modified</span>
+            %endif
+        %endif
+        %if stats['added']:
+        <span class="pill" op="added">+${stats['added']}</span>
+        %endif
+        %if stats['deleted']:
+        <span class="pill" op="deleted">-${stats['deleted']}</span>
+        %endif
+    </span>
+
+</%def>
+
+<%def name="nice_mode(filemode)">
+    ${filemode.startswith('100') and filemode[3:] or filemode}
+</%def>
+
+<%def name="diff_menu(filediff, use_comments=False)">
+    <div class="filediff-menu">
+%if filediff.diffset.source_ref:
+    %if filediff.patch['operation'] in ['D', 'M']:
+        <a
+            class="tooltip"
+            href="${h.url('files_home',repo_name=filediff.diffset.repo_name,f_path=filediff.source_file_path,revision=filediff.diffset.source_ref)}"
+            title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
+        >
+            ${_('Show file before')}
+        </a>
+    %else:
+        <span
+            class="tooltip"
+            title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
+        >
+            ${_('Show file before')}
+        </span>
+    %endif
+    %if filediff.patch['operation'] in ['A', 'M']:
+        <a
+            class="tooltip"
+            href="${h.url('files_home',repo_name=filediff.diffset.repo_name,f_path=filediff.target_file_path,revision=filediff.diffset.target_ref)}"
+            title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
+        >
+            ${_('Show file after')}
+        </a>
+    %else:
+        <span
+            class="tooltip"
+            title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
+            >
+                ${_('Show file after')}
+        </span>
+    %endif
+        <a
+            class="tooltip"
+            title="${h.tooltip(_('Raw diff'))}"
+            href="${h.url('files_diff_home',repo_name=filediff.diffset.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='raw')}"
+        >
+            ${_('Raw diff')}
+        </a>
+        <a
+            class="tooltip"
+            title="${h.tooltip(_('Download diff'))}"
+            href="${h.url('files_diff_home',repo_name=filediff.diffset.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='download')}"
+        >
+            ${_('Download diff')}
+        </a>
+
+        ## TODO: dan: refactor ignorews_url and context_url into the diff renderer same as diffmode=unified/sideside. Also use ajax to load more context (by clicking hunks)
+        %if hasattr(c, 'ignorews_url'):
+        ${c.ignorews_url(request.GET, h.FID('', filediff['patch']['filename']))}
+        %endif
+        %if hasattr(c, 'context_url'):
+        ${c.context_url(request.GET, h.FID('', filediff['patch']['filename']))}
+        %endif
+
+
+        %if use_comments:
+        <a href="#" onclick="return Rhodecode.comments.toggleComments(this);">
+            <span class="show-comment-button">${_('Show comments')}</span><span class="hide-comment-button">${_('Hide comments')}</span>
+        </a>
+        %endif
+%endif
+    </div>
+</%def>
+
+
+<%namespace name="commentblock" file="/changeset/changeset_file_comment.html"/>
+<%def name="inline_comments_container(comments)">
+<div class="inline-comments">
+    %for comment in comments:
+    ${commentblock.comment_block(comment, inline=True)}
+    %endfor
+    <span onclick="return Rhodecode.comments.createComment(this)"
+          class="btn btn-secondary cb-comment-add-button">
+        ${_('Add another comment')}
+    </span>
+</div>
+</%def>
+
+
+<%def name="render_hunk_lines_sideside(hunk, use_comments=False)">
+    %for i, line in enumerate(hunk.sideside):
+    <%
+    old_line_anchor, new_line_anchor = None, None
+    if line.original.lineno:
+        old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, line.original.lineno, 'o')
+    if line.modified.lineno:
+        new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, line.modified.lineno, 'n')
+    %>
+    <tr class="cb-line">
+        <td class="cb-data ${action_class(line.original.action)}"
+            data-line-number="${line.original.lineno}"
+            >
+            <div>
+            %if line.original.comments:
+            <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
+            %endif
+            </div>
+        </td>
+        <td class="cb-lineno ${action_class(line.original.action)}"
+            data-line-number="${line.original.lineno}"
+            %if old_line_anchor:
+            id="${old_line_anchor}"
+            %endif
+        >
+            %if line.original.lineno:
+            <a name="${old_line_anchor}" href="#${old_line_anchor}">${line.original.lineno}</a>
+            %endif
+        </td>
+        <td class="cb-content ${action_class(line.original.action)}"
+            data-line-number="o${line.original.lineno}"
+            >
+            %if use_comments and line.original.lineno:
+            ${render_add_comment_button()}
+            %endif
+            <span class="cb-code">${line.original.action} ${line.original.content or '' | n}</span>
+            %if use_comments and line.original.lineno and line.original.comments:
+            ${inline_comments_container(line.original.comments)}
+            %endif
+        </td>
+        <td class="cb-data ${action_class(line.modified.action)}"
+            data-line-number="${line.modified.lineno}"
+            >
+            <div>
+            %if line.modified.comments:
+            <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
+            %endif
+            </div>
+        </td>
+        <td class="cb-lineno ${action_class(line.modified.action)}"
+            data-line-number="${line.modified.lineno}"
+            %if new_line_anchor:
+            id="${new_line_anchor}"
+            %endif
+            >
+            %if line.modified.lineno:
+                <a name="${new_line_anchor}" href="#${new_line_anchor}">${line.modified.lineno}</a>
+            %endif
+        </td>
+        <td class="cb-content ${action_class(line.modified.action)}"
+            data-line-number="n${line.modified.lineno}"
+            >
+            %if use_comments and line.modified.lineno:
+            ${render_add_comment_button()}
+            %endif
+            <span class="cb-code">${line.modified.action} ${line.modified.content or '' | n}</span>
+            %if use_comments and line.modified.lineno and line.modified.comments:
+            ${inline_comments_container(line.modified.comments)}
+            %endif
+        </td>
+    </tr>
+    %endfor
+</%def>
+
+
+<%def name="render_hunk_lines_unified(hunk, use_comments=False)">
+    %for old_line_no, new_line_no, action, content, comments in hunk.unified:
+    <%
+    old_line_anchor, new_line_anchor = None, None
+    if old_line_no:
+        old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, old_line_no, 'o')
+    if new_line_no:
+        new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, new_line_no, 'n')
+    %>
+    <tr class="cb-line">
+        <td class="cb-data ${action_class(action)}">
+            <div>
+            %if comments:
+            <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
+            %endif
+            </div>
+        </td>
+        <td class="cb-lineno ${action_class(action)}"
+            data-line-number="${old_line_no}"
+            %if old_line_anchor:
+            id="${old_line_anchor}"
+            %endif
+        >
+            %if old_line_anchor:
+            <a name="${old_line_anchor}" href="#${old_line_anchor}">${old_line_no}</a>
+            %endif
+        </td>
+        <td class="cb-lineno ${action_class(action)}"
+            data-line-number="${new_line_no}"
+            %if new_line_anchor:
+            id="${new_line_anchor}"
+            %endif
+        >
+            %if new_line_anchor:
+            <a name="${new_line_anchor}" href="#${new_line_anchor}">${new_line_no}</a>
+            %endif
+        </td>
+        <td class="cb-content ${action_class(action)}"
+            data-line-number="${new_line_no and 'n' or 'o'}${new_line_no or old_line_no}"
+            >
+            %if use_comments:
+            ${render_add_comment_button()}
+            %endif
+            <span class="cb-code">${action} ${content or '' | n}</span>
+            %if use_comments and comments:
+            ${inline_comments_container(comments)}
+            %endif
+        </td>
+    </tr>
+    %endfor
+</%def>
+
+<%def name="render_add_comment_button()">
+<button
+    class="btn btn-small btn-primary cb-comment-box-opener"
+    onclick="return Rhodecode.comments.createComment(this)"
+><span>+</span></button>
+</%def>
+
+<%def name="render_diffset_menu()">
+    <div class="diffset-menu clearinner">
+        <div class="pull-right">
+            <div class="btn-group">
+                <a
+                  class="btn ${c.diffmode == 'sideside' and 'btn-primary'} tooltip"
+                  title="${_('View side by side')}"
+                  href="${h.url_replace(diffmode='sideside')}">
+                    <span>${_('Side by Side')}</span>
+                </a>
+                <a
+                  class="btn ${c.diffmode == 'unified' and 'btn-primary'} tooltip"
+                  title="${_('View unified')}" href="${h.url_replace(diffmode='unified')}">
+                    <span>${_('Unified')}</span>
+                </a>
+            </div>
+        </div>
+        <div class="pull-left">
+          <div class="btn-group">
+              <a
+                  class="btn"
+                  href="#"
+                  onclick="$('input[class=filediff-collapse-state]').prop('checked', false); return false">${_('Expand All')}</a>
+              <a
+                  class="btn"
+                  href="#"
+                  onclick="$('input[class=filediff-collapse-state]').prop('checked', true); return false">${_('Collapse All')}</a>
+          </div>
+        </div>
+    </div>
+</%def>

rhodecode/templates/codeblocks/source.html

@@ -0,0 +1,68 b''
+<%def name="render_line(line_num, tokens,
+                        annotation=None,
+                        bgcolor=None)">
+    <%
+    from rhodecode.lib.codeblocks import render_tokenstream
+    # avoid module lookup for performance
+    html_escape = h.html_escape
+    %>
+    <tr class="cb-line cb-line-fresh"
+    %if annotation:
+    data-revision="${annotation.revision}"
+    %endif
+    >
+    <td class="cb-lineno" id="L${line_num}">
+      <a data-line-no="${line_num}" href="#L${line_num}"></a>
+    </td>
+    <td class="cb-content cb-content-fresh"
+    %if bgcolor:
+    style="background: ${bgcolor}"
+    %endif
+    >
+    ## newline at end is necessary for highlight to work when line is empty
+    ## and for copy pasting code to work as expected
+      <span class="cb-code">${render_tokenstream(tokens)|n}${'\n'}</span>
+    </td>
+  </tr>
+</%def>
+
+<%def name="render_annotation_lines(annotation, lines, color_hasher)">
+  <%
+  rowspan = len(lines) + 1 # span the line's <tr> and annotation <tr>
+  %>
+  %if not annotation:
+  <tr class="cb-annotate">
+    <td class="cb-annotate-message" rowspan="${rowspan}"></td>
+    <td class="cb-annotate-revision" rowspan="${rowspan}"></td>
+  </tr>
+  %else:
+  <tr class="cb-annotate">
+    <td class="cb-annotate-info tooltip"
+        rowspan="${rowspan}"
+        title="Author: ${annotation.author | entity}<br>Date: ${annotation.date}<br>Message: ${annotation.message | entity}"
+    >
+      ${h.gravatar_with_user(annotation.author, 16) | n}
+      <strong class="cb-annotate-message">${
+          h.truncate(annotation.message, len(lines) * 30)
+      }</strong>
+    </td>
+    <td
+      class="cb-annotate-revision"
+      rowspan="${rowspan}"
+      data-revision="${annotation.revision}"
+      onclick="$('[data-revision=${annotation.revision}]').toggleClass('cb-line-fresh')"
+      style="background: ${color_hasher(annotation.raw_id)}">
+    <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=annotation.raw_id)}">
+      r${annotation.revision}
+    </a>
+    </td>
+  </tr>
+  %endif
+
+  %for line_num, tokens in lines:
+    ${render_line(line_num, tokens,
+      bgcolor=color_hasher(annotation and annotation.raw_id or ''),
+      annotation=annotation,
+      )}
+  %endfor
+</%def>

rhodecode/templates/debug_style/alerts.html

@@ -0,0 +1,75 b''
+## -*- coding: utf-8 -*-
+<%inherit file="/debug_style/index.html"/>
+
+<%def name="breadcrumbs_links()">
+    ${h.link_to(_('Style'), h.url('debug_style_home'))}
+    &raquo;
+    ${c.active}
+</%def>
+
+
+<%def name="real_main()">
+<div class="box">
+    <div class="title">
+        ${self.breadcrumbs()}
+    </div>
+
+    <div class='sidebar-col-wrapper'>
+
+      ${self.sidebar()}
+
+      <div class="main-content">
+
+        <h3>Alert Messages</h3>
+        <p>
+          Alert messages are produced using the custom Polymer element
+          <code>rhodecode-toast</code> which is passed a message and level.
+        </p>
+  
+        <div class="bs-example">
+          <p> There are four types of alert levels:</p>
+          <div class="alert alert-success">
+            "success" is used when an action is completed as expected<br/>
+            ex. updated settings, deletion of a repo/user
+          </div>
+          <div class="alert alert-warning">
+            "warning" is for notification of impending issues<br/>
+            ex. a gist which was updated elsewhere during editing, disk out of space
+          </div>
+          <div class="alert alert-error">
+            "error" should be used for unexpected results and actions which
+            are not successful<br/>
+            ex. a form not submitted, repo creation failure
+          </div>
+          <div class="alert alert-info">
+            "info" is used for non-critical information<br/>
+            ex. notification of new messages, invitations to chat
+          </div>
+        </div>
+
+        <p><br/>
+          Whether singular or multiple, alerts are grouped into a dismissable
+          panel with a single "Close" button underneath.
+        </p>
+        <a class="btn btn-default" id="test-notification">Test Notification</a>
+  
+        <script type="text/javascript">
+          $('#test-notification').on('click', function(e){
+            var levels = ['info', 'error', 'warning', 'success'];
+            var level = levels[Math.floor(Math.random()*levels.length)];
+            var payload = {
+              message: {
+                message: 'This is a test ' +level+ ' notification.',
+                level: level,
+                force: true
+              }
+            };
+            $.Topic('/notifications').publish(payload);
+          });
+        </script>
+
+      </div>
+      </div>  <!-- .main-content  -->
+    </div>
+  </div> <!-- .box -->
+</%def>

rhodecode/tests/integrations/conftest.py

@@ -0,0 +1,52 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+import pytest
+from rhodecode import events
+
+
[e-mail]
+def repo_push_event(backend, user_regular):
+    commits = [
+        {'message': 'ancestor commit fixes #15'},
+        {'message': 'quick fixes'},
+        {'message': 'change that fixes #41, #2'},
+        {'message': 'this is because 5b23c3532 broke stuff'},
+        {'message': 'last commit'},
+    ]
+    commit_ids = backend.create_master_repo(commits).values()
+    repo = backend.create_repo()
+    scm_extras = {
+        'ip': '127.0.0.1',
+        'username': user_regular.username,
+        'action': '',
+        'repository': repo.repo_name,
+        'scm': repo.scm_instance().alias,
+        'config': '',
+        'server_url': 'http://example.com',
+        'make_lock': None,
+        'locked_by': [None],
+        'commit_ids': commit_ids,
+    }
+
+    return events.RepoPushEvent(repo_name=repo.repo_name,
+                                pushed_commit_ids=commit_ids,
+                                extras=scm_extras)

rhodecode/tests/integrations/test_webhook.py

@@ -0,0 +1,93 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import pytest
+
+from rhodecode import events
+from rhodecode.lib.utils2 import AttributeDict
+from rhodecode.integrations.types.webhook import WebhookHandler
+
+
[e-mail]
+def base_data():
+    return {
+        'repo': {
+            'repo_name': 'foo',
+            'repo_type': 'hg',
+            'repo_id': '12',
+            'url': 'http://repo.url/foo'
+        }
+    }
+
+
+def test_webhook_parse_url_invalid_event():
+    template_url = 'http://server.com/${repo_name}/build'
+    handler = WebhookHandler(template_url, 'secret_token')
+    with pytest.raises(ValueError) as err:
+        handler(events.RepoDeleteEvent(''), {})
+    assert str(err.value).startswith('event type not supported')
+
+
[e-mail]('template,expected_urls', [
+    ('http://server.com/${repo_name}/build', ['http://server.com/foo/build']),
+    ('http://server.com/${repo_name}/${repo_type}', ['http://server.com/foo/hg']),
+    ('http://${server}.com/${repo_name}/${repo_id}', ['http://${server}.com/foo/12']),
+    ('http://server.com/${branch}/build', ['http://server.com/${branch}/build']),
+])
+def test_webook_parse_url_for_create_event(base_data, template, expected_urls):
+    handler = WebhookHandler(template, 'secret_token')
+    urls = handler(events.RepoCreateEvent(''), base_data)
+    assert urls == [(url, 'secret_token', base_data) for url in expected_urls]
+
+
[e-mail]('template,expected_urls', [
+    ('http://server.com/${repo_name}/${pull_request_id}', ['http://server.com/foo/999']),
+    ('http://server.com/${repo_name}/${pull_request_url}', ['http://server.com/foo/http://pr-url.com']),
+])
+def test_webook_parse_url_for_pull_request_event(base_data, template, expected_urls):
+    base_data['pullrequest'] = {
+        'pull_request_id': 999,
+        'url': 'http://pr-url.com',
+    }
+    handler = WebhookHandler(template, 'secret_token')
+    urls = handler(events.PullRequestCreateEvent(
+        AttributeDict({'target_repo': 'foo'})), base_data)
+    assert urls == [(url, 'secret_token', base_data) for url in expected_urls]
+
+
[e-mail]('template,expected_urls', [
+    ('http://server.com/${branch}/build', ['http://server.com/stable/build',
+                                           'http://server.com/dev/build']),
+    ('http://server.com/${branch}/${commit_id}', ['http://server.com/stable/stable-xxx',
+                                                  'http://server.com/stable/stable-yyy',
+                                                  'http://server.com/dev/dev-xxx',
+                                                  'http://server.com/dev/dev-yyy']),
+])
+def test_webook_parse_url_for_push_event(pylonsapp, repo_push_event, base_data, template, expected_urls):
+    base_data['push'] = {
+        'branches': [{'name': 'stable'}, {'name': 'dev'}],
+        'commits': [{'branch': 'stable', 'raw_id': 'stable-xxx'},
+                    {'branch': 'stable', 'raw_id': 'stable-yyy'},
+                    {'branch': 'dev', 'raw_id': 'dev-xxx'},
+                    {'branch': 'dev', 'raw_id': 'dev-yyy'}]
+    }
+    handler = WebhookHandler(template, 'secret_token')
+    urls = handler(repo_push_event, base_data)
+    assert urls == [(url, 'secret_token', base_data) for url in expected_urls]

rhodecode/tests/lib/test_codeblocks.py

@@ -0,0 +1,330 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import pytest
+
+from rhodecode.lib.codeblocks import (
+    tokenize_string, split_token_stream, rollup_tokenstream,
+    render_tokenstream)
+from pygments.lexers import get_lexer_by_name
+
+
+class TestTokenizeString(object):
+
+    python_code = '''
+    import this
+
+    var = 6
+    print "this"
+
+    '''
+
+    def test_tokenize_as_python(self):
+        lexer = get_lexer_by_name('python')
+        tokens = list(tokenize_string(self.python_code, lexer))
+
+        assert tokens == [
+            ('',    u'\n'),
+            ('',    u'    '),
+            ('kn',  u'import'),
+            ('',    u' '),
+            ('nn',  u'this'),
+            ('',    u'\n'),
+            ('',    u'\n'),
+            ('',    u'    '),
+            ('n',   u'var'),
+            ('',    u' '),
+            ('o',   u'='),
+            ('',    u' '),
+            ('mi',  u'6'),
+            ('',    u'\n'),
+            ('',    u'    '),
+            ('k',   u'print'),
+            ('',    u' '),
+            ('s2',  u'"'),
+            ('s2',  u'this'),
+            ('s2',  u'"'),
+            ('',    u'\n'),
+            ('',    u'\n'),
+            ('',    u'    ')
+        ]
+
+    def test_tokenize_as_text(self):
+        lexer = get_lexer_by_name('text')
+        tokens = list(tokenize_string(self.python_code, lexer))
+
+        assert tokens == [
+            ('',
+            u'\n    import this\n\n    var = 6\n    print "this"\n\n    ')
+        ]
+
+
+class TestSplitTokenStream(object):
+
+    def test_split_token_stream(self):
+        lines = list(split_token_stream(
+            [('type1', 'some\ntext'), ('type2', 'more\n')]))
+
+        assert lines == [
+            [('type1', u'some')],
+            [('type1', u'text'), ('type2', u'more')],
+            [('type2', u'')],
+        ]
+
+    def test_split_token_stream_other_char(self):
+        lines = list(split_token_stream(
+            [('type1', 'some\ntext'), ('type2', 'more\n')],
+            split_string='m'))
+
+        assert lines == [
+            [('type1', 'so')],
+            [('type1', 'e\ntext'), ('type2', '')],
+            [('type2', 'ore\n')],
+        ]
+
+    def test_split_token_stream_without_char(self):
+        lines = list(split_token_stream(
+            [('type1', 'some\ntext'), ('type2', 'more\n')],
+            split_string='z'))
+
+        assert lines == [
+            [('type1', 'some\ntext'), ('type2', 'more\n')]
+        ]
+
+    def test_split_token_stream_single(self):
+        lines = list(split_token_stream(
+            [('type1', '\n')], split_string='\n'))
+
+        assert lines == [
+            [('type1', '')],
+            [('type1', '')],
+        ]
+
+    def test_split_token_stream_single_repeat(self):
+        lines = list(split_token_stream(
+            [('type1', '\n\n\n')], split_string='\n'))
+
+        assert lines == [
+            [('type1', '')],
+            [('type1', '')],
+            [('type1', '')],
+            [('type1', '')],
+        ]
+
+    def test_split_token_stream_multiple_repeat(self):
+        lines = list(split_token_stream(
+            [('type1', '\n\n'), ('type2', '\n\n')], split_string='\n'))
+
+        assert lines == [
+            [('type1', '')],
+            [('type1', '')],
+            [('type1', ''), ('type2', '')],
+            [('type2', '')],
+            [('type2', '')],
+        ]
+
+
+class TestRollupTokens(object):
+
+    @pytest.mark.parametrize('tokenstream,output', [
+        ([],
+            []),
+        ([('A', 'hell'), ('A', 'o')], [
+            ('A', [
+                ('', 'hello')]),
+        ]),
+        ([('A', 'hell'), ('B', 'o')], [
+            ('A', [
+                ('', 'hell')]),
+            ('B', [
+                ('', 'o')]),
+        ]),
+        ([('A', 'hel'), ('A', 'lo'), ('B', ' '), ('A', 'there')], [
+            ('A', [
+                ('', 'hello')]),
+            ('B', [
+                ('', ' ')]),
+            ('A', [
+                ('', 'there')]),
+        ]),
+    ])
+    def test_rollup_tokenstream_without_ops(self, tokenstream, output):
+        assert list(rollup_tokenstream(tokenstream)) == output
+
+    @pytest.mark.parametrize('tokenstream,output', [
+        ([],
+            []),
+        ([('A', '', 'hell'), ('A', '', 'o')], [
+            ('A', [
+                ('', 'hello')]),
+        ]),
+        ([('A', '', 'hell'), ('B', '', 'o')], [
+            ('A', [
+                ('', 'hell')]),
+            ('B', [
+                ('', 'o')]),
+        ]),
+        ([('A', '', 'h'), ('B', '', 'e'), ('C', '', 'y')], [
+            ('A', [
+                ('', 'h')]),
+            ('B', [
+                ('', 'e')]),
+            ('C', [
+                ('', 'y')]),
+        ]),
+        ([('A', '', 'h'), ('A', '', 'e'), ('C', '', 'y')], [
+            ('A', [
+                ('', 'he')]),
+            ('C', [
+                ('', 'y')]),
+        ]),
+        ([('A', 'ins', 'h'), ('A', 'ins', 'e')], [
+            ('A', [
+                ('ins', 'he')
+            ]),
+        ]),
+        ([('A', 'ins', 'h'), ('A', 'del', 'e')], [
+            ('A', [
+                ('ins', 'h'),
+                ('del', 'e')
+            ]),
+        ]),
+        ([('A', 'ins', 'h'), ('B', 'del', 'e'), ('B', 'del', 'y')], [
+            ('A', [
+                ('ins', 'h'),
+            ]),
+            ('B', [
+                ('del', 'ey'),
+            ]),
+        ]),
+        ([('A', 'ins', 'h'), ('A', 'del', 'e'), ('B', 'del', 'y')], [
+            ('A', [
+                ('ins', 'h'),
+                ('del', 'e'),
+            ]),
+            ('B', [
+                ('del', 'y'),
+            ]),
+        ]),
+        ([('A', '', 'some'), ('A', 'ins', 'new'), ('A', '', 'name')], [
+            ('A', [
+                ('', 'some'),
+                ('ins', 'new'),
+                ('', 'name'),
+            ]),
+        ]),
+    ])
+    def test_rollup_tokenstream_with_ops(self, tokenstream, output):
+        assert list(rollup_tokenstream(tokenstream)) == output
+
+
+class TestRenderTokenStream(object):
+
+    @pytest.mark.parametrize('tokenstream,output', [
+        (
+            [],
+            '',
+        ),
+        (
+            [('', '', u'')],
+            '<span></span>',
+        ),
+        (
+            [('', '', u'text')],
+            '<span>text</span>',
+        ),
+        (
+            [('A', '', u'')],
+            '<span class="A"></span>',
+        ),
+        (
+            [('A', '', u'hello')],
+            '<span class="A">hello</span>',
+        ),
+        (
+            [('A', '', u'hel'), ('A', '', u'lo')],
+            '<span class="A">hello</span>',
+        ),
+        (
+            [('A', '', u'two\n'), ('A', '', u'lines')],
+            '<span class="A">two\nlines</span>',
+        ),
+        (
+            [('A', '', u'\nthree\n'), ('A', '', u'lines')],
+            '<span class="A">\nthree\nlines</span>',
+        ),
+        (
+            [('', '', u'\n'), ('A', '', u'line')],
+            '<span>\n</span><span class="A">line</span>',
+        ),
+        (
+            [('', 'ins', u'\n'), ('A', '', u'line')],
+            '<span><ins>\n</ins></span><span class="A">line</span>',
+        ),
+        (
+            [('A', '', u'hel'), ('A', 'ins', u'lo')],
+            '<span class="A">hel<ins>lo</ins></span>',
+        ),
+        (
+            [('A', '', u'hel'), ('A', 'ins', u'l'), ('A', 'ins', u'o')],
+            '<span class="A">hel<ins>lo</ins></span>',
+        ),
+        (
+            [('A', '', u'hel'), ('A', 'ins', u'l'), ('A', 'del', u'o')],
+            '<span class="A">hel<ins>l</ins><del>o</del></span>',
+        ),
+        (
+            [('A', '', u'hel'), ('B', '', u'lo')],
+            '<span class="A">hel</span><span class="B">lo</span>',
+        ),
+        (
+            [('A', '', u'hel'), ('B', 'ins', u'lo')],
+            '<span class="A">hel</span><span class="B"><ins>lo</ins></span>',
+        ),
+    ])
+    def test_render_tokenstream_with_ops(self, tokenstream, output):
+        html = render_tokenstream(tokenstream)
+        assert html == output
+
+    @pytest.mark.parametrize('tokenstream,output', [
+        (
+            [('A', u'hel'), ('A', u'lo')],
+            '<span class="A">hello</span>',
+        ),
+        (
+            [('A', u'hel'), ('A', u'l'), ('A', u'o')],
+            '<span class="A">hello</span>',
+        ),
+        (
+            [('A', u'hel'), ('A', u'l'), ('A', u'o')],
+            '<span class="A">hello</span>',
+        ),
+        (
+            [('A', u'hel'), ('B', u'lo')],
+            '<span class="A">hel</span><span class="B">lo</span>',
+        ),
+        (
+            [('A', u'hel'), ('B', u'lo')],
+            '<span class="A">hel</span><span class="B">lo</span>',
+        ),
+    ])
+    def test_render_tokenstream_without_ops(self, tokenstream, output):
+        html = render_tokenstream(tokenstream)
+        assert html == output

rhodecode/tests/lib/test_system_info.py

@@ -0,0 +1,15 b''
+import py.test
+
+from rhodecode.lib.system_info import get_system_info
+
+
+def test_system_info(app):
+    info = get_system_info({})
+    assert info['load']['value']['15_min'] != 'NOT AVAILABLE'
+
+
+def test_system_info_without_psutil(monkeypatch, app):
+    import rhodecode.lib.system_info
+    monkeypatch.setattr(rhodecode.lib.system_info, 'psutil', None)
+    info = get_system_info({})
+    assert info['load']['value']['15_min'] == 'NOT AVAILABLE'

rhodecode/tests/models/schemas/test_repo_group_schema.py

@@ -0,0 +1,116 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import colander
+import pytest
+
+from rhodecode.model.validation_schema import types
+from rhodecode.model.validation_schema.schemas import repo_group_schema
+
+
+class TestRepoGroupSchema(object):
+
+    @pytest.mark.parametrize('given, expected', [
+        ('my repo', 'my-repo'),
+        (' hello   world mike ', 'hello-world-mike'),
+
+        ('//group1/group2//', 'group1/group2'),
+        ('//group1///group2//', 'group1/group2'),
+        ('///group1/group2///group3', 'group1/group2/group3'),
+        ('word g1/group2///group3', 'word-g1/group2/group3'),
+
+        ('grou p1/gro;,,##up2//.../group3', 'grou-p1/group2/group3'),
+
+        ('group,,,/,,,/1/2/3', 'group/1/2/3'),
+        ('grou[]p1/gro;up2///gro up3', 'group1/group2/gro-up3'),
+        (u'grou[]p1/gro;up2///gro up3/ąć', u'group1/group2/gro-up3/ąć'),
+    ])
+    def test_deserialize_repo_name(self, app, user_admin, given, expected):
+        schema = repo_group_schema.RepoGroupSchema().bind()
+        assert schema.get('repo_group_name').deserialize(given) == expected
+
+    def test_deserialize(self, app, user_admin):
+        schema = repo_group_schema.RepoGroupSchema().bind(
+            user=user_admin
+        )
+
+        schema_data = schema.deserialize(dict(
+            repo_group_name='dupa',
+            repo_group_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_group_name'] == 'dupa'
+        assert schema_data['repo_group'] == {
+            'repo_group_id': None,
+            'repo_group_name': types.RootLocation,
+            'repo_group_name_without_group': 'dupa'}
+
+    @pytest.mark.parametrize('given, err_key, expected_exc', [
+        ('xxx/dupa', 'repo_group', 'Parent repository group `xxx` does not exist'),
+        ('', 'repo_group_name', 'Name must start with a letter or number. Got ``'),
+    ])
+    def test_deserialize_with_bad_group_name(
+            self, app, user_admin, given, err_key, expected_exc):
+        schema = repo_group_schema.RepoGroupSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_group_name=given,
+                repo_group_owner=user_admin.username
+            ))
+
+        assert excinfo.value.asdict()[err_key] == expected_exc
+
+    def test_deserialize_with_group_name(self, app, user_admin, test_repo_group):
+        schema = repo_group_schema.RepoGroupSchema().bind(
+            user=user_admin
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        schema_data = schema.deserialize(dict(
+            repo_group_name=full_name,
+            repo_group_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_group_name'] == full_name
+        assert schema_data['repo_group'] == {
+            'repo_group_id': test_repo_group.group_id,
+            'repo_group_name': test_repo_group.group_name,
+            'repo_group_name_without_group': 'dupa'}
+
+    def test_deserialize_with_group_name_regular_user_no_perms(
+            self, app, user_regular, test_repo_group):
+        schema = repo_group_schema.RepoGroupSchema().bind(
+            user=user_regular
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_group_name=full_name,
+                repo_group_owner=user_regular.username
+            ))
+
+        expected = 'Parent repository group `{}` does not exist'.format(
+            test_repo_group.group_name)
+        assert excinfo.value.asdict()['repo_group'] == expected

rhodecode/tests/models/schemas/test_repo_schema.py

@@ -0,0 +1,128 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016-2016  RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import colander
+import pytest
+
+from rhodecode.model.validation_schema import types
+from rhodecode.model.validation_schema.schemas import repo_schema
+
+
+class TestRepoSchema(object):
+
+    #TODO:
+    # test nested groups
+
+    @pytest.mark.parametrize('given, expected', [
+        ('my repo', 'my-repo'),
+        (' hello   world mike ', 'hello-world-mike'),
+
+        ('//group1/group2//', 'group1/group2'),
+        ('//group1///group2//', 'group1/group2'),
+        ('///group1/group2///group3', 'group1/group2/group3'),
+        ('word g1/group2///group3', 'word-g1/group2/group3'),
+
+        ('grou p1/gro;,,##up2//.../group3', 'grou-p1/group2/group3'),
+
+        ('group,,,/,,,/1/2/3', 'group/1/2/3'),
+        ('grou[]p1/gro;up2///gro up3', 'group1/group2/gro-up3'),
+        (u'grou[]p1/gro;up2///gro up3/ąć', u'group1/group2/gro-up3/ąć'),
+    ])
+    def test_deserialize_repo_name(self, app, user_admin, given, expected):
+
+        schema = repo_schema.RepoSchema().bind()
+        assert expected == schema.get('repo_name').deserialize(given)
+
+    def test_deserialize(self, app, user_admin):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        schema_data = schema.deserialize(dict(
+            repo_name='dupa',
+            repo_type='hg',
+            repo_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_name'] == 'dupa'
+        assert schema_data['repo_group'] == {
+            'repo_group_id': None,
+            'repo_group_name': types.RootLocation,
+            'repo_name_without_group': 'dupa'}
+
+    @pytest.mark.parametrize('given, err_key, expected_exc', [
+        ('xxx/dupa','repo_group', 'Repository group `xxx` does not exist'),
+        ('', 'repo_name', 'Name must start with a letter or number. Got ``'),
+    ])
+    def test_deserialize_with_bad_group_name(
+            self, app, user_admin, given, err_key, expected_exc):
+
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_name=given,
+                repo_type='hg',
+                repo_owner=user_admin.username
+            ))
+
+        assert excinfo.value.asdict()[err_key] == expected_exc
+
+    def test_deserialize_with_group_name(self, app, user_admin, test_repo_group):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_admin
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        schema_data = schema.deserialize(dict(
+            repo_name=full_name,
+            repo_type='hg',
+            repo_owner=user_admin.username
+        ))
+
+        assert schema_data['repo_name'] == full_name
+        assert schema_data['repo_group'] == {
+            'repo_group_id': test_repo_group.group_id,
+            'repo_group_name': test_repo_group.group_name,
+            'repo_name_without_group': 'dupa'}
+
+    def test_deserialize_with_group_name_regular_user_no_perms(
+            self, app, user_regular, test_repo_group):
+        schema = repo_schema.RepoSchema().bind(
+            repo_type_options=['hg'],
+            user=user_regular
+        )
+
+        full_name = test_repo_group.group_name + '/dupa'
+        with pytest.raises(colander.Invalid) as excinfo:
+            schema.deserialize(dict(
+                repo_name=full_name,
+                repo_type='hg',
+                repo_owner=user_regular.username
+            ))
+
+        expected = 'Repository group `{}` does not exist'.format(
+            test_repo_group.group_name)
+        assert excinfo.value.asdict()['repo_group'] == expected

rhodecode/tests/rhodecode.ini

@@ -0,0 +1,716 b''
+
+
+################################################################################
+##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
+# The %(here)s variable will be replaced with the parent directory of this file#
+################################################################################
+
+[DEFAULT]
+debug = true
+
+################################################################################
+##                            EMAIL CONFIGURATION                             ##
+## Uncomment and replace with the email address which should receive          ##
+## any error reports after an application crash                               ##
+## Additionally these settings will be used by the RhodeCode mailing system   ##
+################################################################################
+
+## prefix all emails subjects with given prefix, helps filtering out emails
+#email_prefix = [RhodeCode]
+
+## email FROM address all mails will be sent
+#app_email_from = rhodecode-noreply@localhost
+
+## Uncomment and replace with the address which should receive any error report
+## note: using appenlight for error handling doesn't need this to be uncommented
+#email_to = admin@localhost
+
+## in case of Application errors, sent an error email form
+#error_email_from = rhodecode_error@localhost
+
+## additional error message to be send in case of server crash
+#error_message =
+
+
+#smtp_server = mail.server.com
+#smtp_username =
+#smtp_password =
+#smtp_port =
+#smtp_use_tls = false
+#smtp_use_ssl = true
+## Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
+#smtp_auth =
+
+[server:main]
+## COMMON ##
+host = 0.0.0.0
+port = 5000
+
+##################################
+##     WAITRESS WSGI SERVER     ##
+## Recommended for Development  ##
+##################################
+
+use = egg:waitress#main
+## number of worker threads
+threads = 5
+## MAX BODY SIZE 100GB
+max_request_body_size = 107374182400
+## Use poll instead of select, fixes file descriptors limits problems.
+## May not work on old windows systems.
+asyncore_use_poll = true
+
+
+##########################
+## GUNICORN WSGI SERVER ##
+##########################
+## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
+
+#use = egg:gunicorn#main
+## Sets the number of process workers. You must set `instance_id = *`
+## when this option is set to more than one worker, recommended
+## value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers
+## The `instance_id = *` must be set in the [app:main] section below
+#workers = 2
+## number of threads for each of the worker, must be set to 1 for gevent
+## generally recommened to be at 1
+#threads = 1
+## process name
+#proc_name = rhodecode
+## type of worker class, one of sync, gevent
+## recommended for bigger setup is using of of other than sync one
+#worker_class = sync
+## The maximum number of simultaneous clients. Valid only for Gevent
+#worker_connections = 10
+## max number of requests that worker will handle before being gracefully
+## restarted, could prevent memory leaks
+#max_requests = 1000
+#max_requests_jitter = 30
+## amount of time a worker can spend with handling a request before it
+## gets killed and restarted. Set to 6hrs
+#timeout = 21600
+
+## UWSGI ##
+## run with uwsgi --ini-paste-logged <inifile.ini>
+#[uwsgi]
+#socket = /tmp/uwsgi.sock
+#master = true
+#http = 127.0.0.1:5000
+
+## set as deamon and redirect all output to file
+#daemonize = ./uwsgi_rhodecode.log
+
+## master process PID
+#pidfile = ./uwsgi_rhodecode.pid
+
+## stats server with workers statistics, use uwsgitop
+## for monitoring, `uwsgitop 127.0.0.1:1717`
+#stats = 127.0.0.1:1717
+#memory-report = true
+
+## log 5XX errors
+#log-5xx = true
+
+## Set the socket listen queue size.
+#listen = 256
+
+## Gracefully Reload workers after the specified amount of managed requests
+## (avoid memory leaks).
+#max-requests = 1000
+
+## enable large buffers
+#buffer-size=65535
+
+## socket and http timeouts ##
+#http-timeout=3600
+#socket-timeout=3600
+
+## Log requests slower than the specified number of milliseconds.
+#log-slow = 10
+
+## Exit if no app can be loaded.
+#need-app = true
+
+## Set lazy mode (load apps in workers instead of master).
+#lazy = true
+
+## scaling ##
+## set cheaper algorithm to use, if not set default will be used
+#cheaper-algo = spare
+
+## minimum number of workers to keep at all times
+#cheaper = 1
+
+## number of workers to spawn at startup
+#cheaper-initial = 1
+
+## maximum number of workers that can be spawned
+#workers = 4
+
+## how many workers should be spawned at a time
+#cheaper-step = 1
+
+## prefix middleware for RhodeCode.
+## recommended when using proxy setup.
+## allows to set RhodeCode under a prefix in server.
+## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
+## optionally set prefix like: `prefix = /<your-prefix>`
+[filter:proxy-prefix]
+use = egg:PasteDeploy#prefix
+prefix = /
+
+[app:main]
+is_test = True
+use = egg:rhodecode-enterprise-ce
+
+## enable proxy prefix middleware, defined above
+#filter-with = proxy-prefix
+
+
+## RHODECODE PLUGINS ##
+rhodecode.includes = rhodecode.api
+
+# api prefix url
+rhodecode.api.url = /_admin/api
+
+
+## END RHODECODE PLUGINS ##
+
+## encryption key used to encrypt social plugin tokens,
+## remote_urls with credentials etc, if not set it defaults to
+## `beaker.session.secret`
+#rhodecode.encrypted_values.secret =
+
+## decryption strict mode (enabled by default). It controls if decryption raises
+## `SignatureVerificationError` in case of wrong key, or damaged encryption data.
+#rhodecode.encrypted_values.strict = false
+
+## return gzipped responses from Rhodecode (static files/application)
+gzip_responses = false
+
+## autogenerate javascript routes file on startup
+generate_js_files = false
+
+## Optional Languages
+## en(default), be, de, es, fr, it, ja, pl, pt, ru, zh
+lang = en
+
+## perform a full repository scan on each server start, this should be
+## set to false after first startup, to allow faster server restarts.
+startup.import_repos = true
+
+## Uncomment and set this path to use archive download cache.
+## Once enabled, generated archives will be cached at this location
+## and served from the cache during subsequent requests for the same archive of
+## the repository.
+#archive_cache_dir = /tmp/tarballcache
+
+## change this to unique ID for security
+app_instance_uuid = rc-production
+
+## cut off limit for large diffs (size in bytes)
+cut_off_limit_diff = 1024000
+cut_off_limit_file = 256000
+
+## use cache version of scm repo everywhere
+vcs_full_cache = false
+
+## force https in RhodeCode, fixes https redirects, assumes it's always https
+## Normally this is controlled by proper http flags sent from http server
+force_https = false
+
+## use Strict-Transport-Security headers
+use_htsts = false
+
+## number of commits stats will parse on each iteration
+commit_parse_limit = 25
+
+## 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 = --all
+
+# Set to true if your repos are exposed using the dumb protocol
+git_update_server_info = false
+
+## RSS/ATOM feed options
+rss_cut_off_limit = 256000
+rss_items_per_page = 10
+rss_include_diff = false
+
+## 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.rhodecode.org/{gistid}. Empty means use the internal
+## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
+gist_alias_url =
+
+## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
+## used for access.
+## Adding ?auth_token = <token> to the url authenticates this request as if it
+## came from the the logged in user who own this authentication token.
+##
+## Syntax is <ControllerClass>:<function_pattern>.
+## To enable access to raw_files put `FilesController:raw`.
+## To enable access to patches add `ChangesetController:changeset_patch`.
+## The list should be "," separated and on a single line.
+##
+## Recommended controllers to enable:
+#    ChangesetController:changeset_patch,
+#    ChangesetController:changeset_raw,
+#    FilesController:raw,
+#    FilesController:archivefile,
+#    GistsController:*,
+api_access_controllers_whitelist =
+
+## 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 = UTF-8
+
+## instance-id prefix
+## a prefix key for this instance used for cache invalidation when running
+## multiple instances of rhodecode, make sure it's globally unique for
+## all running rhodecode instances. Leave empty if you don't use it
+instance_id =
+
+## Fallback authentication plugin. Set this to a plugin ID to force the usage
+## of an authentication plugin also if it is disabled by it's settings.
+## This could be useful if you are unable to log in to the system due to broken
+## authentication settings. Then you can enable e.g. the internal rhodecode auth
+## module to log in again and fix the settings.
+##
+## Available builtin plugin IDs (hash is part of the ID):
+## egg:rhodecode-enterprise-ce#rhodecode
+## egg:rhodecode-enterprise-ce#pam
+## egg:rhodecode-enterprise-ce#ldap
+## egg:rhodecode-enterprise-ce#jasig_cas
+## egg:rhodecode-enterprise-ce#headers
+## egg:rhodecode-enterprise-ce#crowd
+#rhodecode.auth_plugin_fallback = egg:rhodecode-enterprise-ce#rhodecode
+
+## alternative return HTTP header for failed authentication. Default HTTP
+## response is 401 HTTPUnauthorized. Currently HG clients have troubles with
+## handling that causing a series of failed authentication calls.
+## Set this variable to 403 to return HTTPForbidden, or any other HTTP code
+## This will be served instead of default 401 on bad authnetication
+auth_ret_code =
+
+## use special detection method when serving auth_ret_code, instead of serving
+## ret_code directly, use 401 initially (Which triggers credentials prompt)
+## and then serve auth_ret_code to clients
+auth_ret_code_detection = false
+
+## 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
+
+## generated license token, goto license page in RhodeCode settings to obtain
+## new token
+license_token = abra-cada-bra1-rce3
+
+## supervisor connection uri, for managing supervisor and logs.
+supervisor.uri =
+## supervisord group name/id we only want this RC instance to handle
+supervisor.group_id = dev
+
+## Display extended labs settings
+labs_settings_active = true
+
+####################################
+###        CELERY CONFIG        ####
+####################################
+use_celery = false
+broker.host = localhost
+broker.vhost = rabbitmqhost
+broker.port = 5672
+broker.user = rabbitmq
+broker.password = qweqwe
+
+celery.imports = rhodecode.lib.celerylib.tasks
+
+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.log.file = celeryd.log
+celeryd.log.level = debug
+celeryd.max.tasks.per.child = 1
+
+## tasks will never be sent to the queue, but executed locally instead.
+celery.always.eager = false
+
+####################################
+###         BEAKER CACHE        ####
+####################################
+# default cache dir for templates.  Putting this into a ramdisk
+## can boost performance, eg. %(here)s/data_ramdisk
+cache_dir = %(here)s/data
+
+## locking and default file storage for Beaker. Putting this into a ramdisk
+## can boost performance, eg. %(here)s/data_ramdisk/cache/beaker_data
+beaker.cache.data_dir = %(here)s/rc/data/cache/beaker_data
+beaker.cache.lock_dir = %(here)s/rc/data/cache/beaker_lock
+
+beaker.cache.regions = super_short_term, short_term, long_term, sql_cache_short, auth_plugins, repo_cache_long
+
+beaker.cache.super_short_term.type = memory
+beaker.cache.super_short_term.expire = 1
+beaker.cache.super_short_term.key_length = 256
+
+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 = 1
+beaker.cache.sql_cache_short.key_length = 256
+
+## default is memory cache, configure only if required
+## using multi-node or multi-worker setup
+#beaker.cache.auth_plugins.type = ext:database
+#beaker.cache.auth_plugins.lock_dir = %(here)s/data/cache/auth_plugin_lock
+#beaker.cache.auth_plugins.url = postgresql://postgres:secret@localhost/rhodecode
+#beaker.cache.auth_plugins.url = mysql://root:secret@127.0.0.1/rhodecode
+#beaker.cache.auth_plugins.sa.pool_recycle = 3600
+#beaker.cache.auth_plugins.sa.pool_size = 10
+#beaker.cache.auth_plugins.sa.max_overflow = 0
+
+beaker.cache.repo_cache_long.type = memorylru_base
+beaker.cache.repo_cache_long.max_items = 4096
+beaker.cache.repo_cache_long.expire = 2592000
+
+## default is memorylru_base cache, configure only if required
+## using multi-node or multi-worker setup
+#beaker.cache.repo_cache_long.type = ext:memcached
+#beaker.cache.repo_cache_long.url = localhost:11211
+#beaker.cache.repo_cache_long.expire = 1209600
+#beaker.cache.repo_cache_long.key_length = 256
+
+####################################
+###       BEAKER SESSION        ####
+####################################
+
+## .session.type is type of storage options for the session, current allowed
+## types are file, ext:memcached, ext:database, and memory (default).
+beaker.session.type = file
+beaker.session.data_dir = %(here)s/rc/data/sessions/data
+
+## db based session, fast, and allows easy management over logged in users
+#beaker.session.type = ext:database
+#beaker.session.table_name = db_session
+#beaker.session.sa.url = postgresql://postgres:secret@localhost/rhodecode
+#beaker.session.sa.url = mysql://root:secret@127.0.0.1/rhodecode
+#beaker.session.sa.pool_recycle = 3600
+#beaker.session.sa.echo = false
+
+beaker.session.key = rhodecode
+beaker.session.secret = test-rc-uytcxaz
+beaker.session.lock_dir = %(here)s/rc/data/sessions/lock
+
+## Secure encrypted cookie. Requires AES and AES python libraries
+## you must disable beaker.session.secret to use this
+#beaker.session.encrypt_key = <key_for_encryption>
+#beaker.session.validate_key = <validation_key>
+
+## sets session as invalid(also logging out user) if it haven not been
+## accessed for given amount of time in seconds
+beaker.session.timeout = 2592000
+beaker.session.httponly = true
+## Path to use for the cookie.
+#beaker.session.cookie_path = /<your-prefix>
+
+## uncomment for https secure cookie
+beaker.session.secure = false
+
+## auto save the session to not to use .save()
+beaker.session.auto = false
+
+## default cookie expiration time in seconds, set to `true` to set expire
+## at browser close
+#beaker.session.cookie_expires = 3600
+
+###################################
+## SEARCH INDEXING CONFIGURATION ##
+###################################
+## Full text search indexer is available in rhodecode-tools under
+## `rhodecode-tools index` command
+
+# WHOOSH Backend, doesn't require additional services to run
+# it works good with few dozen repos
+search.module = rhodecode.lib.index.whoosh
+search.location = %(here)s/data/index
+
+########################################
+###    CHANNELSTREAM CONFIG         ####
+########################################
+## channelstream enables persistent connections and live notification
+## in the system. It's also used by the chat system
+
+channelstream.enabled = false
+# location of channelstream server on the backend
+channelstream.server = 127.0.0.1:9800
+## location of the channelstream server from outside world
+## most likely this would be an http server special backend URL, that handles
+## websocket connections see nginx example for config
+channelstream.ws_url = ws://rhodecode.yourserver.com/_channelstream
+channelstream.secret = secret
+channelstream.history.location = %(here)s/channelstream_history
+
+
+###################################
+##       APPENLIGHT CONFIG       ##
+###################################
+
+## Appenlight is tailored to work with RhodeCode, see
+## http://appenlight.com for details how to obtain an account
+
+## appenlight integration enabled
+appenlight = false
+
+appenlight.server_url = https://api.appenlight.com
+appenlight.api_key = YOUR_API_KEY
+#appenlight.transport_config = https://api.appenlight.com?threaded=1&timeout=5
+
+# used for JS client
+appenlight.api_public_key = YOUR_API_PUBLIC_KEY
+
+## TWEAK AMOUNT OF INFO SENT HERE
+
+## enables 404 error logging (default False)
+appenlight.report_404 = false
+
+## time in seconds after request is considered being slow (default 1)
+appenlight.slow_request_time = 1
+
+## record slow requests in application
+## (needs to be enabled for slow datastore recording and time tracking)
+appenlight.slow_requests = true
+
+## enable hooking to application loggers
+appenlight.logging = true
+
+## minimum log level for log capture
+appenlight.logging.level = WARNING
+
+## send logs only from erroneous/slow requests
+## (saves API quota for intensive logging)
+appenlight.logging_on_error = false
+
+## list of additonal keywords that should be grabbed from environ object
+## can be string with comma separated list of words in lowercase
+## (by default client will always send following info:
+## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that
+## start with HTTP* this list be extended with additional keywords here
+appenlight.environ_keys_whitelist =
+
+## list of keywords that should be blanked from request object
+## can be string with comma separated list of words in lowercase
+## (by default client will always blank keys that contain following words
+## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'
+## this list be extended with additional keywords set here
+appenlight.request_keys_blacklist =
+
+## list of namespaces that should be ignores when gathering log entries
+## can be string with comma separated list of namespaces
+## (by default the client ignores own entries: appenlight_client.client)
+appenlight.log_namespace_blacklist =
+
+
+################################################################################
+## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
+## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
+## execute malicious code after an exception is raised.                       ##
+################################################################################
+set debug = false
+
+
+##############
+## STYLING  ##
+##############
+debug_style = false
+
+#########################################################
+### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
+#########################################################
+#sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode_test.db
+#sqlalchemy.db1.url = postgresql://postgres:qweqwe@localhost/rhodecode_test
+#sqlalchemy.db1.url = mysql://root:qweqwe@localhost/rhodecode_test
+sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode_test.db
+
+# see sqlalchemy docs for other advanced settings
+
+## print the sql statements to output
+sqlalchemy.db1.echo = false
+## recycle the connections after this ammount of seconds
+sqlalchemy.db1.pool_recycle = 3600
+sqlalchemy.db1.convert_unicode = true
+
+## the number of connections to keep open inside the connection pool.
+## 0 indicates no limit
+#sqlalchemy.db1.pool_size = 5
+
+## the number of connections to allow in connection pool "overflow", that is
+## connections that can be opened above and beyond the pool_size setting,
+## which defaults to five.
+#sqlalchemy.db1.max_overflow = 10
+
+
+##################
+### VCS CONFIG ###
+##################
+vcs.server.enable = true
+vcs.server = localhost:9901
+
+## Web server connectivity protocol, responsible for web based VCS operatations
+## Available protocols are:
+## `pyro4` - using pyro4 server
+## `http` - using http-rpc backend
+vcs.server.protocol = http
+
+## Push/Pull operations protocol, available options are:
+## `pyro4` - using pyro4 server
+## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
+## `vcsserver.scm_app` - internal app (EE only)
+vcs.scm_app_implementation = http
+
+## Push/Pull operations hooks protocol, available options are:
+## `pyro4` - using pyro4 server
+## `http` - using http-rpc backend
+vcs.hooks.protocol = http
+
+vcs.server.log_level = debug
+## Start VCSServer with this instance as a subprocess, usefull for development
+vcs.start_server = false
+
+## List of enabled VCS backends, available options are:
+## `hg`  - mercurial
+## `git` - git
+## `svn` - subversion
+vcs.backends = hg, git, svn
+
+vcs.connection_timeout = 3600
+## Compatibility version when creating SVN repositories. Defaults to newest version when commented out.
+## Available options are: pre-1.4-compatible, pre-1.5-compatible, pre-1.6-compatible, pre-1.8-compatible
+#vcs.svn.compatible_version = pre-1.8-compatible
+
+
+############################################################
+### Subversion proxy support (mod_dav_svn)               ###
+### Maps RhodeCode repo groups into SVN paths for Apache ###
+############################################################
+## Enable or disable the config file generation.
+svn.proxy.generate_config = false
+## Generate config file with `SVNListParentPath` set to `On`.
+svn.proxy.list_parent_path = true
+## Set location and file name of generated config file.
+svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
+## File system path to the directory containing the repositories served by
+## RhodeCode.
+svn.proxy.parent_path_root = /path/to/repo_store
+## Used as a prefix to the <Location> block in the generated config file. In
+## most cases it should be set to `/`.
+svn.proxy.location_root = /
+
+
+################################
+### LOGGING CONFIGURATION   ####
+################################
+[loggers]
+keys = root, routes, rhodecode, sqlalchemy, beaker, pyro4, templates
+
+[handlers]
+keys = console, console_sql
+
+[formatters]
+keys = generic, color_formatter, color_formatter_sql
+
+#############
+## LOGGERS ##
+#############
+[logger_root]
+level = NOTSET
+handlers = console
+
+[logger_routes]
+level = DEBUG
+handlers =
+qualname = routes.middleware
+## "level = DEBUG" logs the route matched and routing variables.
+propagate = 1
+
+[logger_beaker]
+level = DEBUG
+handlers =
+qualname = beaker.container
+propagate = 1
+
+[logger_pyro4]
+level = DEBUG
+handlers =
+qualname = Pyro4
+propagate = 1
+
+[logger_templates]
+level = INFO
+handlers =
+qualname = pylons.templating
+propagate = 1
+
+[logger_rhodecode]
+level = DEBUG
+handlers =
+qualname = rhodecode
+propagate = 1
+
+[logger_sqlalchemy]
+level = ERROR
+handlers = console_sql
+qualname = sqlalchemy.engine
+propagate = 0
+
+##############
+## HANDLERS ##
+##############
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = DEBUG
+formatter = generic
+
+[handler_console_sql]
+class = StreamHandler
+args = (sys.stderr,)
+level = WARN
+formatter = generic
+
+################
+## FORMATTERS ##
+################
+
+[formatter_generic]
+class = rhodecode.lib.logging_formatter.Pyro4AwareFormatter
+format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S
+
+[formatter_color_formatter]
+class = rhodecode.lib.logging_formatter.ColorFormatter
+format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S
+
+[formatter_color_formatter_sql]
+class = rhodecode.lib.logging_formatter.ColorFormatterSql
+format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S

rhodecode/tests/vcsserver_http.ini

@@ -0,0 +1,83 b''
+################################################################################
+# RhodeCode VCSServer with HTTP Backend - configuration                        #
+#                                                                              #
+################################################################################
+
+[app:main]
+use = egg:rhodecode-vcsserver
+
+pyramid.default_locale_name = en
+pyramid.includes =
+pyramid.reload_templates = true
+
+# default locale used by VCS systems
+locale = en_US.UTF-8
+
+# cache regions, please don't change
+beaker.cache.regions = repo_object
+beaker.cache.repo_object.type = memorylru
+beaker.cache.repo_object.max_items = 100
+# cache auto-expires after N seconds
+beaker.cache.repo_object.expire = 300
+beaker.cache.repo_object.enabled = true
+
+[server:main]
+use = egg:waitress#main
+host = 127.0.0.1
+port = 9900
+
+################################
+### LOGGING CONFIGURATION   ####
+################################
+[loggers]
+keys = root, vcsserver, pyro4, beaker
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+#############
+## LOGGERS ##
+#############
+[logger_root]
+level = NOTSET
+handlers = console
+
+[logger_vcsserver]
+level = DEBUG
+handlers =
+qualname = vcsserver
+propagate = 1
+
+[logger_beaker]
+level = DEBUG
+handlers =
+qualname = beaker
+propagate = 1
+
+[logger_pyro4]
+level = DEBUG
+handlers =
+qualname = Pyro4
+propagate = 1
+
+
+##############
+## HANDLERS ##
+##############
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = INFO
+formatter = generic
+
+################
+## FORMATTERS ##
+################
+
+[formatter_generic]
+format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S

rhodecode/tests/vcsserver_pyro4.ini

@@ -0,0 +1,79 b''
+################################################################################
+# RhodeCode VCSServer - configuration                                          #
+#                                                                              #
+################################################################################
+
+[DEFAULT]
+host = 127.0.0.1
+port = 9900
+locale = en_US.UTF-8
+# number of worker threads, this should be set based on a formula threadpool=N*6
+# where N is number of RhodeCode Enterprise workers, eg. running 2 instances
+# 8 gunicorn workers each would be 2 * 8 * 6 = 96, threadpool_size = 96
+threadpool_size = 96
+timeout = 0
+
+# cache regions, please don't change
+beaker.cache.regions = repo_object
+beaker.cache.repo_object.type = memorylru
+beaker.cache.repo_object.max_items = 100
+# cache auto-expires after N seconds
+beaker.cache.repo_object.expire = 300
+beaker.cache.repo_object.enabled = true
+
+
+################################
+### LOGGING CONFIGURATION   ####
+################################
+[loggers]
+keys = root, vcsserver, pyro4, beaker
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+#############
+## LOGGERS ##
+#############
+[logger_root]
+level = NOTSET
+handlers = console
+
+[logger_vcsserver]
+level = DEBUG
+handlers =
+qualname = vcsserver
+propagate = 1
+
+[logger_beaker]
+level = DEBUG
+handlers =
+qualname = beaker
+propagate = 1
+
+[logger_pyro4]
+level = DEBUG
+handlers =
+qualname = Pyro4
+propagate = 1
+
+
+##############
+## HANDLERS ##
+##############
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = INFO
+formatter = generic
+
+################
+## FORMATTERS ##
+################
+
+[formatter_generic]
+format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S

.bumpversion.cfg

@@ -1,5 +1,5 b''
 [bumpversion]
-current_version = 4.4.2
+current_version = 4.5.0
 message = release: Bump version {current_version} to {new_version}
 
 [bumpversion:file:rhodecode/VERSION]

.hgignore

@@ -43,6 +43,7 b' syntax: regexp'
 ^rhodecode/public/css/style-polymer.css$
 ^rhodecode/public/js/rhodecode-components.html$
 ^rhodecode/public/js/scripts.js$
+^rhodecode/public/js/rhodecode-components.js$
 ^rhodecode/public/js/src/components/root-styles.gen.html$
 ^rhodecode/public/js/vendors/webcomponentsjs/
 ^rhodecode\.db$

.release.cfg

@@ -4,26 +4,21 b' done = false'
 [task:bump_version]
 done = true
 
-[task:rc_tools_pinned]
-done = true
-
 [task:fixes_on_stable]
-done = true
 
 [task:pip2nix_generated]
-done = true
 
 [task:changelog_updated]
-done = true
 
 [task:generate_api_docs]
-done = true
+
+[task:updated_translation]
 
 [release]
-state = prepared
-version = 4.4.2
+state = in_progress
+version = 4.5.0
 
-[task:updated_translation]
+[task:rc_tools_pinned]
 
 [task:generate_js_routes]
 

Gruntfile.js

@@ -11,5 +11,5 b' module.exports = function(grunt) {'
   grunt.loadNpmTasks('grunt-crisper');
   grunt.loadNpmTasks('grunt-contrib-copy');
 
-  grunt.registerTask('default', ['less:production', 'less:components', 'concat:polymercss', 'copy','vulcanize', 'crisper', 'concat:dist']);
+  grunt.registerTask('default', ['less:production', 'less:components', 'concat:polymercss', 'copy', 'concat:dist', 'vulcanize', 'crisper']);
 };

LICENSE.txt

@@ -12,6 +12,10 b' permission notice:'
        file:licenses/msgpack_license.txt
    Copyright (c) 2009 - tornado
        file:licenses/tornado_license.txt
+   Copyright (c) 2015 - pygments-markdown-lexer
+       file:licenses/pygments_markdown_lexer_license.txt
+   Copyright 2006 - diff_match_patch
+       file:licenses/diff_match_patch_license.txt
 
 All licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

Makefile

@@ -2,7 +2,6 b''
 WEBPACK=./node_modules/webpack/bin/webpack.js
 GRUNT=grunt
 NODE_PATH=./node_modules
-FLAKE8=flake8 setup.py pytest_pylons/ rhodecode/ --select=E124 --ignore=E711,E712,E510,E121,E122,E126,E127,E128,E501,F401 --max-line-length=100 --exclude=*rhodecode/lib/dbmigrate/*,*rhodecode/tests/*,*rhodecode/lib/vcs/utils/*
 CI_PREFIX=enterprise
 
 .PHONY: docs docs-clean ci-docs clean test test-clean test-lint test-only
@@ -25,13 +24,6 b' test: test-clean test-only'
 test-clean:
 	rm -rf coverage.xml htmlcov junit.xml pylint.log result
 
-test-lint:
-	if [ "$$IN_NIX_SHELL" = "1" ]; then \
-		$(FLAKE8); \
-	else \
-		$(FLAKE8) --format=pylint --exit-zero > pylint.log; \
-	fi
-
 test-only:
 	PYTHONHASHSEED=random py.test -vv -r xw --cov=rhodecode --cov-report=term-missing --cov-report=html rhodecode/tests/
 

bower.json

@@ -10,6 +10,8 b''
     "paper-tooltip": "PolymerElements/paper-tooltip#^1.1.2",
     "paper-toast": "PolymerElements/paper-toast#^1.3.0",
     "paper-toggle-button": "PolymerElements/paper-toggle-button#^1.2.0",
-    "iron-ajax": "PolymerElements/iron-ajax#^1.4.3"
+    "iron-ajax": "PolymerElements/iron-ajax#^1.4.3",
+    "iron-autogrow-textarea": "PolymerElements/iron-autogrow-textarea#^1.0.13",
+    "iron-a11y-keys": "PolymerElements/iron-a11y-keys#^1.0.6"
   }
 }

configs/development.ini

@@ -1,7 +1,7 b''
 
 
 ################################################################################
-##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
+##                 RHODECODE COMMUNITY EDITION CONFIGURATION                  ##
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 
@@ -64,7 +64,7 b' asyncore_use_poll = true'
 ##########################
 ## GUNICORN WSGI SERVER ##
 ##########################
-## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
+## run with gunicorn --log-config rhodecode.ini --paste rhodecode.ini
 
 #use = egg:gunicorn#main
 ## Sets the number of process workers. You must set `instance_id = *`
@@ -91,11 +91,13 b' asyncore_use_poll = true'
 #timeout = 21600
 
 
-## prefix middleware for RhodeCode, disables force_https flag.
+## prefix middleware for RhodeCode.
 ## recommended when using proxy setup.
 ## allows to set RhodeCode under a prefix in server.
-## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
-## optionally set prefix like: `prefix = /<your-prefix>`
+## eg https://server.com/custom_prefix. Enable `filter-with =` option below as well.
+## And set your prefix like: `prefix = /custom_prefix`
+## be sure to also set beaker.session.cookie_path = /custom_prefix if you need
+## to make your cookies only work on prefix url
 [filter:proxy-prefix]
 use = egg:PasteDeploy#prefix
 prefix = /
@@ -194,17 +196,17 b' rss_items_per_page = 10'
 rss_include_diff = false
 
 ## gist URL alias, used to create nicer urls for gist. This should be an
-## url that does rewrites to _admin/gists/<gistid>.
+## url that does rewrites to _admin/gists/{gistid}.
 ## example: http://gist.rhodecode.org/{gistid}. Empty means use the internal
-## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
+## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/{gistid}
 gist_alias_url =
 
 ## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
 ## used for access.
-## Adding ?auth_token = <token> to the url authenticates this request as if it
+## Adding ?auth_token=TOKEN_HASH to the url authenticates this request as if it
 ## came from the the logged in user who own this authentication token.
 ##
-## Syntax is <ControllerClass>:<function_pattern>.
+## Syntax is ControllerClass:function_pattern.
 ## To enable access to raw_files put `FilesController:raw`.
 ## To enable access to patches add `ChangesetController:changeset_patch`.
 ## The list should be "," separated and on a single line.
@@ -377,15 +379,15 b' beaker.session.lock_dir = %(here)s/data/'
 
 ## Secure encrypted cookie. Requires AES and AES python libraries
 ## you must disable beaker.session.secret to use this
-#beaker.session.encrypt_key = <key_for_encryption>
-#beaker.session.validate_key = <validation_key>
+#beaker.session.encrypt_key = key_for_encryption
+#beaker.session.validate_key = validation_key
 
 ## sets session as invalid(also logging out user) if it haven not been
 ## accessed for given amount of time in seconds
 beaker.session.timeout = 2592000
 beaker.session.httponly = true
-## Path to use for the cookie.
-#beaker.session.cookie_path = /<your-prefix>
+## Path to use for the cookie. Set to prefix if you use prefix middleware
+#beaker.session.cookie_path = /custom_prefix
 
 ## uncomment for https secure cookie
 beaker.session.secure = false
@@ -403,8 +405,8 b' beaker.session.auto = false'
 ## Full text search indexer is available in rhodecode-tools under
 ## `rhodecode-tools index` command
 
-# WHOOSH Backend, doesn't require additional services to run
-# it works good with few dozen repos
+## WHOOSH Backend, doesn't require additional services to run
+## it works good with few dozen repos
 search.module = rhodecode.lib.index.whoosh
 search.location = %(here)s/data/index
 
@@ -511,7 +513,7 b' sqlalchemy.db1.url = sqlite:///%(here)s/'
 
 ## print the sql statements to output
 sqlalchemy.db1.echo = false
-## recycle the connections after this ammount of seconds
+## recycle the connections after this amount of seconds
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.db1.convert_unicode = true
 
@@ -533,19 +535,19 b' vcs.server = localhost:9900'
 
 ## Web server connectivity protocol, responsible for web based VCS operatations
 ## Available protocols are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
 vcs.server.protocol = http
 
 ## Push/Pull operations protocol, available options are:
-## `pyro4` - using pyro4 server
-## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
-## `vcsserver.scm_app` - internal app (EE only)
-vcs.scm_app_implementation = rhodecode.lib.middleware.utils.scm_app_http
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
+##
+vcs.scm_app_implementation = http
 
 ## Push/Pull operations hooks protocol, available options are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
 vcs.hooks.protocol = http
 
 vcs.server.log_level = debug
@@ -574,12 +576,15 b' svn.proxy.generate_config = false'
 svn.proxy.list_parent_path = true
 ## Set location and file name of generated config file.
 svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
-## File system path to the directory containing the repositories served by
-## RhodeCode.
-svn.proxy.parent_path_root = /path/to/repo_store
-## Used as a prefix to the <Location> block in the generated config file. In
-## most cases it should be set to `/`.
+## Used as a prefix to the `Location` block in the generated config file.
+## In most cases it should be set to `/`.
 svn.proxy.location_root = /
+## Command to reload the mod dav svn configuration on change.
+## Example: `/etc/init.d/apache2 reload`
+#svn.proxy.reload_cmd = /etc/init.d/apache2 reload
+## If the timeout expires before the reload command finishes, the command will
+## be killed. Setting it to zero means no timeout. Defaults to 10 seconds.
+#svn.proxy.reload_timeout = 10
 
 
 ################################

configs/production.ini

@@ -1,7 +1,7 b''
 
 
 ################################################################################
-##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
+##                 RHODECODE COMMUNITY EDITION CONFIGURATION                  ##
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 
@@ -64,7 +64,7 b' port = 5000'
 ##########################
 ## GUNICORN WSGI SERVER ##
 ##########################
-## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
+## run with gunicorn --log-config rhodecode.ini --paste rhodecode.ini
 
 use = egg:gunicorn#main
 ## Sets the number of process workers. You must set `instance_id = *`
@@ -91,11 +91,13 b' max_requests_jitter = 30'
 timeout = 21600
 
 
-## prefix middleware for RhodeCode, disables force_https flag.
+## prefix middleware for RhodeCode.
 ## recommended when using proxy setup.
 ## allows to set RhodeCode under a prefix in server.
-## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
-## optionally set prefix like: `prefix = /<your-prefix>`
+## eg https://server.com/custom_prefix. Enable `filter-with =` option below as well.
+## And set your prefix like: `prefix = /custom_prefix`
+## be sure to also set beaker.session.cookie_path = /custom_prefix if you need
+## to make your cookies only work on prefix url
 [filter:proxy-prefix]
 use = egg:PasteDeploy#prefix
 prefix = /
@@ -168,17 +170,17 b' rss_items_per_page = 10'
 rss_include_diff = false
 
 ## gist URL alias, used to create nicer urls for gist. This should be an
-## url that does rewrites to _admin/gists/<gistid>.
+## url that does rewrites to _admin/gists/{gistid}.
 ## example: http://gist.rhodecode.org/{gistid}. Empty means use the internal
-## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
+## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/{gistid}
 gist_alias_url =
 
 ## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
 ## used for access.
-## Adding ?auth_token = <token> to the url authenticates this request as if it
+## Adding ?auth_token=TOKEN_HASH to the url authenticates this request as if it
 ## came from the the logged in user who own this authentication token.
 ##
-## Syntax is <ControllerClass>:<function_pattern>.
+## Syntax is ControllerClass:function_pattern.
 ## To enable access to raw_files put `FilesController:raw`.
 ## To enable access to patches add `ChangesetController:changeset_patch`.
 ## The list should be "," separated and on a single line.
@@ -351,15 +353,15 b' beaker.session.lock_dir = %(here)s/data/'
 
 ## Secure encrypted cookie. Requires AES and AES python libraries
 ## you must disable beaker.session.secret to use this
-#beaker.session.encrypt_key = <key_for_encryption>
-#beaker.session.validate_key = <validation_key>
+#beaker.session.encrypt_key = key_for_encryption
+#beaker.session.validate_key = validation_key
 
 ## sets session as invalid(also logging out user) if it haven not been
 ## accessed for given amount of time in seconds
 beaker.session.timeout = 2592000
 beaker.session.httponly = true
-## Path to use for the cookie.
-#beaker.session.cookie_path = /<your-prefix>
+## Path to use for the cookie. Set to prefix if you use prefix middleware
+#beaker.session.cookie_path = /custom_prefix
 
 ## uncomment for https secure cookie
 beaker.session.secure = false
@@ -377,8 +379,8 b' beaker.session.auto = false'
 ## Full text search indexer is available in rhodecode-tools under
 ## `rhodecode-tools index` command
 
-# WHOOSH Backend, doesn't require additional services to run
-# it works good with few dozen repos
+## WHOOSH Backend, doesn't require additional services to run
+## it works good with few dozen repos
 search.module = rhodecode.lib.index.whoosh
 search.location = %(here)s/data/index
 
@@ -480,7 +482,7 b' sqlalchemy.db1.url = postgresql://postgr'
 
 ## print the sql statements to output
 sqlalchemy.db1.echo = false
-## recycle the connections after this ammount of seconds
+## recycle the connections after this amount of seconds
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.db1.convert_unicode = true
 
@@ -502,20 +504,20 b' vcs.server = localhost:9900'
 
 ## Web server connectivity protocol, responsible for web based VCS operatations
 ## Available protocols are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
-#vcs.server.protocol = http
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
+vcs.server.protocol = http
 
 ## Push/Pull operations protocol, available options are:
-## `pyro4` - using pyro4 server
-## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
-## `vcsserver.scm_app` - internal app (EE only)
-#vcs.scm_app_implementation = rhodecode.lib.middleware.utils.scm_app_http
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
+##
+vcs.scm_app_implementation = http
 
 ## Push/Pull operations hooks protocol, available options are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
-#vcs.hooks.protocol = http
+## `pyro4` - use pyro4 server
+## `http` - use http-rpc backend (default)
+vcs.hooks.protocol = http
 
 vcs.server.log_level = info
 ## Start VCSServer with this instance as a subprocess, usefull for development
@@ -543,12 +545,15 b' svn.proxy.generate_config = false'
 svn.proxy.list_parent_path = true
 ## Set location and file name of generated config file.
 svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
-## File system path to the directory containing the repositories served by
-## RhodeCode.
-svn.proxy.parent_path_root = /path/to/repo_store
-## Used as a prefix to the <Location> block in the generated config file. In
-## most cases it should be set to `/`.
+## Used as a prefix to the `Location` block in the generated config file.
+## In most cases it should be set to `/`.
 svn.proxy.location_root = /
+## Command to reload the mod dav svn configuration on change.
+## Example: `/etc/init.d/apache2 reload`
+#svn.proxy.reload_cmd = /etc/init.d/apache2 reload
+## If the timeout expires before the reload command finishes, the command will
+## be killed. Setting it to zero means no timeout. Defaults to 10 seconds.
+#svn.proxy.reload_timeout = 10
 
 
 ################################

default.nix

@@ -4,27 +4,55 b''
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
 
-{ pkgs ? (import <nixpkgs> {})
-, pythonPackages ? "python27Packages"
+args@
+{ pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
 , doCheck ? true
+, ...
 }:
 
-let pkgs_ = pkgs; in
-
 let
-  pkgs = pkgs_.overridePackages (self: super: {
-    # Override subversion derivation to
-    #  - activate python bindings
-    #  - set version to 1.8
-    subversion = super.subversion18.override {
-       httpSupport = true;
-       pythonBindings = true;
-       python = self.python27Packages.python;
-    };
+
+  # Use nixpkgs from args or import them. We use this indirect approach
+  # through args to be able to use the name `pkgs` for our customized packages.
+  # Otherwise we will end up with an infinite recursion.
+  nixpkgs = args.pkgs or (import <nixpkgs> { });
+
+  # johbo: Interim bridge which allows us to build with the upcoming
+  # nixos.16.09 branch (unstable at the moment of writing this note) and the
+  # current stable nixos-16.03.
+  backwardsCompatibleFetchgit = { ... }@args:
+    let
+      origSources = nixpkgs.fetchgit args;
+    in
+    nixpkgs.lib.overrideDerivation origSources (oldAttrs: {
+      NIX_PREFETCH_GIT_CHECKOUT_HOOK = ''
+        find $out -name '.git*' -print0 | xargs -0 rm -rf
+      '';
+    });
+
+  # Create a customized version of nixpkgs which should be used throughout the
+  # rest of this file.
+  pkgs = nixpkgs.overridePackages (self: super: {
+    fetchgit = backwardsCompatibleFetchgit;
   });
 
-  inherit (pkgs.lib) fix extends;
+  # Evaluates to the last segment of a file system path.
+  basename = path: with pkgs.lib; last (splitString "/" path);
+
+  # source code filter used as arugment to builtins.filterSource.
+  src-filter = path: type: with pkgs.lib;
+    let
+      ext = last (splitString "." path);
+    in
+      !builtins.elem (basename path) [
+        ".git" ".hg" "__pycache__" ".eggs"
+        "bower_components" "node_modules"
+        "build" "data" "result" "tmp"] &&
+      !builtins.elem ext ["egg-info" "pyc"] &&
+      # TODO: johbo: This check is wrong, since "path" contains an absolute path,
+      # it would still be good to restore it since we want to ignore "result-*".
+      !hasPrefix "result" path;
 
   basePythonPackages = with builtins; if isAttrs pythonPackages
     then pythonPackages
@@ -34,25 +62,6 b' let'
     pkgs.buildBowerComponents or
     (import ./pkgs/backport-16.03-build-bower-components.nix { inherit pkgs; });
 
-  elem = builtins.elem;
-  basename = path: with pkgs.lib; last (splitString "/" path);
-  startsWith = prefix: full: let
-    actualPrefix = builtins.substring 0 (builtins.stringLength prefix) full;
-  in actualPrefix == prefix;
-
-  src-filter = path: type: with pkgs.lib;
-    let
-      ext = last (splitString "." path);
-    in
-      !elem (basename path) [
-        ".git" ".hg" "__pycache__" ".eggs"
-        "bower_components" "node_modules"
-        "build" "data" "result" "tmp"] &&
-      !elem ext ["egg-info" "pyc"] &&
-      # TODO: johbo: This check is wrong, since "path" contains an absolute path,
-      # it would still be good to restore it since we want to ignore "result-*".
-      !startsWith "result" path;
-
   sources = pkgs.config.rc.sources or {};
   version = builtins.readFile ./rhodecode/VERSION;
   rhodecode-enterprise-ce-src = builtins.filterSource src-filter ./.;
@@ -147,18 +156,6 b' let'
         then "${pkgs.glibcLocales}/lib/locale/locale-archive"
         else "";
 
-      # Somewhat snappier setup of the development environment
-      # TODO: move into shell.nix
-      # TODO: think of supporting a stable path again, so that multiple shells
-      #       can share it.
-      shellHook = ''
-        tmp_path=$(mktemp -d)
-        export PATH="$tmp_path/bin:$PATH"
-        export PYTHONPATH="$tmp_path/${self.python.sitePackages}:$PYTHONPATH"
-        mkdir -p $tmp_path/${self.python.sitePackages}
-        python setup.py develop --prefix $tmp_path --allow-hosts ""
-      '' + linkNodeAndBowerPackages;
-
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
@@ -226,16 +223,16 b' let'
   rhodecode-testdata-src = sources.rhodecode-testdata or (
     pkgs.fetchhg {
       url = "https://code.rhodecode.com/upstream/rc_testdata";
-      rev = "v0.8.0";
-      sha256 = "0hy1ba134rq2f9si85yx7j4qhc9ky0hjzdk553s3q026i7km809m";
+      rev = "v0.9.0";
+      sha256 = "0k0ccb7cncd6mmzwckfbr6l7fsymcympwcm948qc3i0f0m6bbg1y";
   });
 
   # Apply all overrides and fix the final package set
-  myPythonPackagesUnfix =
+  myPythonPackagesUnfix = with pkgs.lib;
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
     (extends pythonOverrides
              pythonGeneratedPackages)));
-  myPythonPackages = (fix myPythonPackagesUnfix);
+  myPythonPackages = (pkgs.lib.fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-enterprise-ce

docs/admin/admin-tricks.rst

@@ -62,6 +62,24 b' 3. Select :guilabel:`Save`, and you will'
 
 .. _md-rst:
 
+
+Suppress license warnings or errors
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In case you're running on maximum allowed users, RhodeCode will display a
+warning message on pages that you're close to the license limits.
+It's often not desired to show that all the time. Here's how you can suppress
+the license messages.
+
+1. From the |RCE| interface, select
+   :menuselection:`Admin --> Settings --> Global`
+2. Select :guilabel:`Flash message filtering` from the drop-down menu.
+3. Select :guilabel:`Save`, and you will no longer see the license message
+   once your page refreshes.
+
+.. _admin-tricks-suppress-license-messages:
+
+
 Markdown or RST Rendering
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 

docs/admin/apache-subdirectory.rst

@@ -7,10 +7,11 b' Use the following example to configure A'
 
 .. code-block:: apache
 
-    <Location /<someprefix> > # Change <someprefix> into your chosen prefix
-      ProxyPass http://127.0.0.1:5000/<someprefix>
-      ProxyPassReverse http://127.0.0.1:5000/<someprefix>
-      SetEnvIf X-Url-Scheme https HTTPS=1
+    <Location /<someprefix>/ # Change <someprefix> into your chosen prefix
+      ProxyPreserveHost On
+      ProxyPass "http://127.0.0.1:5000/"
+      ProxyPassReverse "http://127.0.0.1:5000/"
+      Header set X-Url-Scheme https env=HTTPS
     </Location>
 
 In addition to the regular Apache setup you will need to add the following

docs/admin/backup-restore.rst

@@ -9,9 +9,14 b' Backup and Restore'
 To snapshot an instance of |RCE|, and save its settings, you need to backup the
 following parts of the system at the same time.
 
-* The |repos| managed by the instance.
+* The |repos| managed by the instance together with the stored Gists.
 * The |RCE| database.
-* Any configuration files or extensions that you've configured.
+* Any configuration files or extensions that you've configured. In most
+  cases it's only the :file:`rhodecode.ini` file.
+* Installer files such as those in `/opt/rhodecode` can be backed-up, however
+  it's not required since in case of a recovery installer simply
+  re-creates those.
+
 
 .. important::
 
@@ -29,11 +34,17 b' Repository Backup'
 ^^^^^^^^^^^^^^^^^
 
 To back up your |repos|, use the API to get a list of all |repos| managed,
-and then clone them to your backup location.
+and then clone them to your backup location. This is the most safe backup option.
+Backing up the storage directory could potentially result in a backup of
+partially committed files or commits. (Backup taking place during a big push)
+As an alternative you could use a rsync or simple `cp` commands if you can
+ensure your instance is only in read-only mode or stopped at the moment.
+
 
 Use the ``get_repos`` method to list all your managed |repos|,
 and use the ``clone_uri`` information that is returned. See the :ref:`api`
-for more information.
+for more information. Be sure to keep the structure or repositories with their
+repository groups.
 
 .. important::
 
@@ -54,13 +65,19 b' backup location:'
 .. code-block:: bash
 
    # For MySQL DBs
-   $ mysqldump -u <uname> -p <pass> db_name > mysql-db-backup
+   $ mysqldump -u <uname> -p <pass> rhodecode_db_name > mysql-db-backup
+   # MySQL restore command
+   $ mysql -u <uname> -p <pass> rhodecode_db_name < mysql-db-backup
 
    # For PostgreSQL DBs
-   $ pg_dump dbname > postgresql-db-backup
+   $ PGPASSWORD=<pass> pg_dump rhodecode_db_name > postgresql-db-backup
+   # PosgreSQL restore
+   $ PGPASSWORD=<pass> psql -U <uname> -h localhost -d rhodecode_db_name -1 -f postgresql-db-backup
 
-   # For SQLlite
+   # For SQLite
    $ sqlite3 rhodecode.db ‘.dump’ > sqlite-db-backup
+   # SQLite restore
+   $ copy sqlite-db-backup rhodecode.db
 
 
 The default |RCE| SQLite database location is
@@ -75,13 +92,18 b' Configuration File Backup'
 Depending on your setup, you could have a number of configuration files that
 should be backed up. You may have some, or all of the configuration files
 listed in the :ref:`config-rce-files` section. Ideally you should back these
-up at the same time as the database and |repos|.
+up at the same time as the database and |repos|. It really depends on if you need
+the configuration file like logs, custom modules. We always recommend backing
+those up.
 
 Gist Backup
 ^^^^^^^^^^^
 
-To backup the gists on your |RCE| instance you can use the ``get_users`` and
-``get_gists`` API methods to fetch the gists for each user on the instance.
+To backup the gists on your |RCE| instance you usually have to backup the
+gist storage path. If this haven't been changed it's located inside
+:file:`.rc_gist_store` and the metadata in :file:`.rc_gist_metadata`.
+You can use the ``get_users`` and ``get_gists`` API methods to fetch the
+gists for each user on the instance.
 
 Extension Backups
 ^^^^^^^^^^^^^^^^^
@@ -100,15 +122,17 b' the :ref:`indexing-ref` section.'
 Restoration Steps
 -----------------
 
-To restore an instance of |RCE| from its backed up components, use the
-following steps.
+To restore an instance of |RCE| from its backed up components, to a fresh
+system use the following steps.
 
-1. Install a new instance of |RCE|.
-2. Once installed, configure the instance to use the backed up
-   :file:`rhodecode.ini` file. Ensure this file points to the backed up
+1. Install a new instance of |RCE| using sqlite option as database.
+2. Restore your database.
+3. Once installed, replace you backed up the :file:`rhodecode.ini` with your
+   backup version. Ensure this file points to the restored
    database, see the :ref:`config-database` section.
-3. Restart |RCE| and remap and rescan your |repos|, see the
-   :ref:`remap-rescan` section.
+4. Restart |RCE| and remap and rescan your |repos| to verify filesystem access,
+   see the :ref:`remap-rescan` section.
+
 
 Post Restoration Steps
 ^^^^^^^^^^^^^^^^^^^^^^

docs/admin/reset-information.rst

@@ -22,8 +22,8 b' account permissions.'
 .. code-block:: bash
 
     # Open iShell from the terminal
-    $ .rccontrol/enterprise-5/profile/bin/paster \
-        ishell .rccontrol/enterprise-5/rhodecode.ini
+    $ .rccontrol/enterprise-1/profile/bin/paster \
+        ishell .rccontrol/enterprise-1/rhodecode.ini
 
 .. code-block:: mysql
 
@@ -52,11 +52,12 b' following example to make changes to thi'
 .. code-block:: mysql
 
   # Use this example to enable global .hgrc access
-  In [4]: new_option = RhodeCodeUi()
-  In [5]: new_option.ui_section='web'
-  In [6]: new_option.ui_key='allow_push'
-  In [7]: new_option.ui_value='*'
-  In [8]: Session().add(new_option);Session().commit()
+  In [1]: new_option = RhodeCodeUi()
+  In [2]: new_option.ui_section='web'
+  In [3]: new_option.ui_key='allow_push'
+  In [4]: new_option.ui_value='*'
+  In [5]: Session().add(new_option);Session().commit()
+  In [6]: exit()
 
 Manually Reset Password
 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,24 +73,47 b' Use the following code example to carry '
 .. code-block:: bash
 
     # starts the ishell interactive prompt
-    $ .rccontrol/enterprise-5/profile/bin/paster \
-        ishell .rccontrol/enterprise-5/rhodecode.ini
+    $ .rccontrol/enterprise-1/profile/bin/paster \
+        ishell .rccontrol/enterprise-1/rhodecode.ini
 
 .. code-block:: mysql
 
-    from rhodecode.lib.auth import generate_auth_token
-    from rhodecode.lib.auth import get_crypt_password
-
+    In [1]: from rhodecode.lib.auth import generate_auth_token
+    In [2]: from rhodecode.lib.auth import get_crypt_password
     # Enter the user name whose password you wish to change
-    my_user = 'USERNAME'
-    u = User.get_by_username(my_user)
-
+    In [3]: my_user = 'USERNAME'
+    In [4]: u = User.get_by_username(my_user)
     # If this fails then the user does not exist
-    u.auth_token = generate_auth_token(my_user)
-
+    In [5]: u.auth_token = generate_auth_token(my_user)
     # Set the new password
-    u.password = get_crypt_password('PASSWORD')
+    In [6]: u.password = get_crypt_password('PASSWORD')
+    In [7]: Session().add(u);Session().commit()
+    In [8]: exit()
+
+
+
+Change user details
+^^^^^^^^^^^^^^^^^^^
+
+If you need to manually change some of users details, use the following steps.
+
+1. Navigate to your |RCE| install location.
+2. Run the interactive ``ishell`` prompt.
+3. Set a new arguments for users.
 
-    Session().add(u)
-    Session().commit()
-    exit
+Use the following code example to carry out these steps.
+
+.. code-block:: bash
+
+    # starts the ishell interactive prompt
+    $ .rccontrol/enterprise-1/profile/bin/paster \
+        ishell .rccontrol/enterprise-1/rhodecode.ini
+
+.. code-block:: mysql
+
+    # Use this example to change email and username of LDAP user
+    In [1]: my_user = User.get_by_username('some_username')
+    In [2]: my_user.email = '[e-mail]'
+    In [3]: my_user.username = 'SomeUser'
+    In [4]: Session().add(my_user);Session().commit()
+    In [5]: exit()

docs/admin/sec-your-server.rst

@@ -36,7 +36,7 b' 1. On your local machine create the publ'
     Your public key has been saved in /home/user/.ssh/id_rsa.pub.
     The key fingerprint is:
     02:82:38:95:e5:30:d2:ad:17:60:15:7f:94:17:9f:30 user@ubuntu
-    The key's randomart image is:
+    The key\'s randomart image is:
     +--[ RSA 2048]----+
 
 2. SFTP to your server, and copy the public key to the ``~/.ssh`` folder.

docs/admin/system-admin.rst

@@ -18,6 +18,7 b' The following are the most common system'
 
     config-files-overview
     vcs-server
+    svn-http
     apache-config
     nginx-config
     backup-restore

docs/admin/tuning-change-large-file-dir.rst

@@ -18,7 +18,7 b' 1. Open ishell from the terminal and use'
 2. Run the following commands, and ensure that |RCE| has write access to the
    new directory:
 
-.. code-block:: mysql
+.. code-block:: bash
 
     # Once logged into the database, use SQL to redirect
     # the large files location

docs/admin/vcs-server.rst

@@ -298,133 +298,7 b' For a more detailed explanation of the l'
     format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
     datefmt = %Y-%m-%d %H:%M:%S
 
-.. _svn-http:
-
-|svn| With Write Over HTTP
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To use |svn| with read/write support over the |svn| HTTP protocol, you have to
-configure the HTTP |svn| backend.
-
-Prerequisites
-=============
-
-- Enable HTTP support inside the admin VCS settings on your |RCE| instance
-- You need to install the following tools on the machine that is running an
-  instance of |RCE|:
-  ``Apache HTTP Server`` and
-  ``mod_dav_svn``.
-
-
-Using Ubuntu Distribution as an example you can run:
-
-.. code-block:: bash
-
-    $ sudo apt-get install apache2 libapache2-mod-svn
-
-Once installed you need to enable ``dav_svn``:
-
-.. code-block:: bash
-
-    $ sudo a2enmod dav_svn
-
-Configuring Apache Setup
-========================
-
-.. tip::
-
-   It is recommended to run Apache on a port other than 80, due to possible
-   conflicts with other HTTP servers like nginx. To do this, set the
-   ``Listen`` parameter in the ``/etc/apache2/ports.conf`` file, for example
-   ``Listen 8090``.
-
-
-.. warning::
-
-   Make sure your Apache instance which runs the mod_dav_svn module is
-   only accessible by RhodeCode. Otherwise everyone is able to browse
-   the repositories or run subversion operations (checkout/commit/etc.).
-
-It is also recommended to run apache as the same user as |RCE|, otherwise
-permission issues could occur. To do this edit the ``/etc/apache2/envvars``
-
-   .. code-block:: apache
-
-      export APACHE_RUN_USER=rhodecode
-      export APACHE_RUN_GROUP=rhodecode
-
-1. To configure Apache, create and edit a virtual hosts file, for example
-   :file:`/etc/apache2/sites-available/default.conf`. Below is an example
-   how to use one with auto-generated config ```mod_dav_svn.conf```
-   from configured |RCE| instance.
-
-.. code-block:: apache
-
-    <VirtualHost *:8080>
-        ServerAdmin rhodecode-admin@localhost
-        DocumentRoot /var/www/html
-        ErrorLog ${'${APACHE_LOG_DIR}'}/error.log
-        CustomLog ${'${APACHE_LOG_DIR}'}/access.log combined
-        Include /home/user/.rccontrol/enterprise-1/mod_dav_svn.conf
-    </VirtualHost>
-
-
-2. Go to the :menuselection:`Admin --> Settings --> VCS` page, and
-   enable :guilabel:`Proxy Subversion HTTP requests`, and specify the
-   :guilabel:`Subversion HTTP Server URL`.
-
-3. Open the |RCE| configuration file,
-   :file:`/home/{user}/.rccontrol/{instance-id}/rhodecode.ini`
-
-4. Add the following configuration option in the ``[app:main]``
-   section if you don't have it yet.
-
-   This enables mapping of the created |RCE| repo groups into special |svn| paths.
-   Each time a new repository group is created, the system will update
-   the template file and create new mapping. Apache web server needs to be
-   reloaded to pick up the changes on this file.
-   It's recommended to add reload into a crontab so the changes can be picked
-   automatically once someone creates a repository group inside RhodeCode.
-
-
-.. code-block:: ini
-
-    ##############################################
-    ### Subversion proxy support (mod_dav_svn) ###
-    ##############################################
-    ## Enable or disable the config file generation.
-    svn.proxy.generate_config = true
-    ## Generate config file with `SVNListParentPath` set to `On`.
-    svn.proxy.list_parent_path = true
-    ## Set location and file name of generated config file.
-    svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
-    ## File system path to the directory containing the repositories served by
-    ## RhodeCode.
-    svn.proxy.parent_path_root = /path/to/repo_store
-    ## Used as a prefix to the <Location> block in the generated config file. In
-    ## most cases it should be set to `/`.
-    svn.proxy.location_root = /
-
-
-This would create a special template file called ```mod_dav_svn.conf```. We
-used that file path in the apache config above inside the Include statement.
-
-
-Using |svn|
-===========
-
-Once |svn| has been enabled on your instance, you can use it with the
-following examples. For more |svn| information, see the `Subversion Red Book`_
-
-.. code-block:: bash
-
-    # To clone a repository
-    svn checkout http://my-svn-server.example.com/my-svn-repo
-
-    # svn commit
-    svn commit
 
 .. _Subversion Red Book: http://svnbook.red-bean.com/en/1.7/svn-book.html#svn.ref.svn
 
-
-.. _Ask Ubuntu: http://askubuntu.com/questions/162391/how-do-i-fix-my-locale-issue
  No newline at end of file
+.. _Ask Ubuntu: http://askubuntu.com/questions/162391/how-do-i-fix-my-locale-issue

docs/api/methods/deprecated-methods.rst

@@ -1,7 +1,7 b''
 .. _deprecated-methods-ref:
 
 deprecated methods
-=================
+==================
 
 changeset_comment 
 -----------------

docs/api/methods/gist-methods.rst

@@ -1,7 +1,7 b''
 .. _gist-methods-ref:
 
 gist methods
-=================
+============
 
 create_gist 
 -----------

docs/api/methods/license-methods.rst

@@ -1,10 +1,10 b''
 .. _license-methods-ref:
 
 license methods
-=================
+===============
 
 get_license_info (EE only)
-----------------
+--------------------------
 
 .. py:function:: get_license_info(apiuser)
 
@@ -32,7 +32,7 b' get_license_info (EE only)'
 
 
 set_license_key (EE only)
----------------
+-------------------------
 
 .. py:function:: set_license_key(apiuser, key)
 

docs/api/methods/pull-request-methods.rst

@@ -1,7 +1,7 b''
 .. _pull-request-methods-ref:
 
 pull_request methods
-=================
+====================
 
 close_pull_request 
 ------------------
@@ -103,6 +103,10 b' create_pull_request'
    :type description: Optional(str)
    :param reviewers: Set the new pull request reviewers list.
    :type reviewers: Optional(list)
+       Accepts username strings or objects of the format:
+       {
+           'username': 'nick', 'reasons': ['original author']
+       }
 
 
 get_pull_request 
@@ -165,6 +169,15 b' get_pull_request'
                                         "commit_id": "<commit_id>",
                                     }
                                 },
+           "merge":             {
+                                    "clone_url":   "<clone_url>",
+                                    "reference":
+                                    {
+                                        "name":      "<name>",
+                                        "type":      "<type>",
+                                        "commit_id": "<commit_id>",
+                                    }
+                                },
           "author":             <user_obj>,
           "reviewers":          [
                                     ...
@@ -241,6 +254,15 b' get_pull_requests'
                                             "commit_id": "<commit_id>",
                                         }
                                     },
+               "merge":             {
+                                        "clone_url":   "<clone_url>",
+                                        "reference":
+                                        {
+                                            "name":      "<name>",
+                                            "type":      "<type>",
+                                            "commit_id": "<commit_id>",
+                                        }
+                                    },
               "author":             <user_obj>,
               "reviewers":          [
                                         ...
@@ -284,7 +306,12 b' merge_pull_request'
            "executed":         "<bool>",
            "failure_reason":   "<int>",
            "merge_commit_id":  "<merge_commit_id>",
-           "possible":         "<bool>"
+           "possible":         "<bool>",
+           "merge_ref":        {
+                                   "commit_id": "<commit_id>",
+                                   "type":      "<type>",
+                                   "name":      "<name>"
+                               }
        },
      "error": null
 

docs/api/methods/repo-group-methods.rst

@@ -1,24 +1,25 b''
 .. _repo-group-methods-ref:
 
 repo_group methods
-=================
+==================
 
 create_repo_group 
 -----------------
 
-.. py:function:: create_repo_group(apiuser, group_name, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, copy_permissions=<Optional:False>)
+.. py:function:: create_repo_group(apiuser, group_name, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, copy_permissions=<Optional:False>)
 
    Creates a repository group.
 
-   * If the repository group name contains "/", all the required repository
-     groups will be created.
+   * If the repository group name contains "/", repository group will be
+     created inside a repository group or nested repository groups
 
-     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-     (with "foo" as parent). It will also create the "baz" repository
-     with "bar" as |repo| group.
+     For example "foo/bar/group1" will create repository group called "group1"
+     inside group "foo/bar". You have to have permissions to access and
+     write to the last repository group ("bar" in this example)
 
-   This command can only be run using an |authtoken| with admin
-   permissions.
+   This command can only be run using an |authtoken| with at least
+   permissions to create repository groups, or admin permissions to
+   parent repository groups.
 
    :param apiuser: This is filled automatically from the |authtoken|.
    :type apiuser: AuthUser
@@ -73,7 +74,7 b' delete_repo_group'
 
      id : <id_given_in_input>
      result : {
-       'msg': 'deleted repo group ID:<repogroupid> <repogroupname>
+       'msg': 'deleted repo group ID:<repogroupid> <repogroupname>'
        'repo_group': null
      }
      error :  null
@@ -325,13 +326,22 b' revoke_user_permission_from_repo_group'
 update_repo_group 
 -----------------
 
-.. py:function:: update_repo_group(apiuser, repogroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, parent=<Optional:None>, enable_locking=<Optional:False>)
+.. py:function:: update_repo_group(apiuser, repogroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, enable_locking=<Optional:False>)
 
    Updates repository group with the details given.
 
    This command can only be run using an |authtoken| with admin
    permissions.
 
+   * If the group_name name contains "/", repository group will be updated
+     accordingly with a repository group or nested repository groups
+
+     For example repogroupid=group-test group_name="foo/bar/group-test"
+     will update repository group called "group-test" and place it
+     inside group "foo/bar".
+     You have to have permissions to access and write to the last repository
+     group ("bar" in this example)
+
    :param apiuser: This is filled automatically from the |authtoken|.
    :type apiuser: AuthUser
    :param repogroupid: Set the ID of repository group.
@@ -342,8 +352,6 b' update_repo_group'
    :type description: str
    :param owner: Set the |repo| group owner.
    :type owner: str
-   :param parent: Set the |repo| group parent.
-   :type parent: str or int
    :param enable_locking: Enable |repo| locking. The default is false.
    :type enable_locking: bool
 

docs/api/methods/repo-methods.rst

@@ -1,7 +1,7 b''
 .. _repo-methods-ref:
 
 repo methods
-=================
+============
 
 add_field_to_repo 
 -----------------
@@ -68,15 +68,16 b' create_repo'
 
    Creates a repository.
 
-   * If the repository name contains "/", all the required repository
-     groups will be created.
+   * If the repository name contains "/", repository will be created inside
+     a repository group or nested repository groups
 
-     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-     (with "foo" as parent). It will also create the "baz" repository
-     with "bar" as |repo| group.
+     For example "foo/bar/repo1" will create |repo| called "repo1" inside
+     group "foo/bar". You have to have permissions to access and write to
+     the last repository group ("bar" in this example)
 
    This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
+   permissions to create repositories, or write permissions to
+   parent repository groups.
 
    :param apiuser: This is filled automatically from the |authtoken|.
    :type apiuser: AuthUser
@@ -88,9 +89,9 b' create_repo'
    :type owner: Optional(str)
    :param description: Set the repository description.
    :type description: Optional(str)
-   :param private:
+   :param private: set repository as private
    :type private: bool
-   :param clone_uri:
+   :param clone_uri: set clone_uri
    :type clone_uri: str
    :param landing_rev: <rev_type>:<rev>
    :type landing_rev: str
@@ -125,7 +126,7 b' create_repo'
      id : <id_given_in_input>
      result : null
      error :  {
-        'failed to create repository `<repo_name>`
+        'failed to create repository `<repo_name>`'
      }
 
 
@@ -164,25 +165,29 b' delete_repo'
 fork_repo 
 ---------
 
-.. py:function:: fork_repo(apiuser, repoid, fork_name, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, copy_permissions=<Optional:False>, private=<Optional:False>, landing_rev=<Optional:'rev:tip'>)
+.. py:function:: fork_repo(apiuser, repoid, fork_name, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, copy_permissions=<Optional:False>)
 
    Creates a fork of the specified |repo|.
 
-   * If using |RCE| with Celery this will immediately return a success
-     message, even though the fork will be created asynchronously.
+   * If the fork_name contains "/", fork will be created inside
+     a repository group or nested repository groups
 
-   This command can only be run using an |authtoken| with fork
-   permissions on the |repo|.
+     For example "foo/bar/fork-repo" will create fork called "fork-repo"
+     inside group "foo/bar". You have to have permissions to access and
+     write to the last repository group ("bar" in this example)
+
+   This command can only be run using an |authtoken| with minimum
+   read permissions of the forked repo, create fork permissions for an user.
 
    :param apiuser: This is filled automatically from the |authtoken|.
    :type apiuser: AuthUser
    :param repoid: Set repository name or repository ID.
    :type repoid: str or int
-   :param fork_name: Set the fork name.
+   :param fork_name: Set the fork name, including it's repository group membership.
    :type fork_name: str
    :param owner: Set the fork owner.
    :type owner: str
-   :param description: Set the fork descripton.
+   :param description: Set the fork description.
    :type description: str
    :param copy_permissions: Copy permissions from parent |repo|. The
        default is False.
@@ -729,7 +734,7 b' lock'
      id : <id_given_in_input>
      result : null
      error :  {
-       'Error occurred locking repository `<reponame>`
+       'Error occurred locking repository `<reponame>`'
      }
 
 
@@ -923,24 +928,31 b' strip'
 update_repo 
 -----------
 
-.. py:function:: update_repo(apiuser, repoid, name=<Optional:None>, owner=<Optional:<OptionalAttr:apiuser>>, group=<Optional:None>, fork_of=<Optional:None>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, fields=<Optional:''>)
+.. py:function:: update_repo(apiuser, repoid, repo_name=<Optional:None>, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, fork_of=<Optional:None>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, fields=<Optional:''>)
 
    Updates a repository with the given information.
 
    This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
+   admin permissions to the |repo|.
+
+   * If the repository name contains "/", repository will be updated
+     accordingly with a repository group or nested repository groups
+
+     For example repoid=repo-test name="foo/bar/repo-test" will update |repo|
+     called "repo-test" and place it inside group "foo/bar".
+     You have to have permissions to access and write to the last repository
+     group ("bar" in this example)
 
    :param apiuser: This is filled automatically from the |authtoken|.
    :type apiuser: AuthUser
    :param repoid: repository name or repository ID.
    :type repoid: str or int
-   :param name: Update the |repo| name.
-   :type name: str
+   :param repo_name: Update the |repo| name, including the
+       repository group it's in.
+   :type repo_name: str
    :param owner: Set the |repo| owner.
    :type owner: str
-   :param group: Set the |repo| group the |repo| belongs to.
-   :type group: str
-   :param fork_of: Set the master |repo| name.
+   :param fork_of: Set the |repo| as fork of another |repo|.
    :type fork_of: str
    :param description: Update the |repo| description.
    :type description: str
@@ -948,16 +960,13 b' update_repo'
    :type private: bool
    :param clone_uri: Update the |repo| clone URI.
    :type clone_uri: str
-   :param landing_rev: Set the |repo| landing revision. Default is
-       ``tip``.
+   :param landing_rev: Set the |repo| landing revision. Default is ``rev:tip``.
    :type landing_rev: str
-   :param enable_statistics: Enable statistics on the |repo|,
-       (True | False).
+   :param enable_statistics: Enable statistics on the |repo|, (True | False).
    :type enable_statistics: bool
    :param enable_locking: Enable |repo| locking.
    :type enable_locking: bool
-   :param enable_downloads: Enable downloads from the |repo|,
-       (True | False).
+   :param enable_downloads: Enable downloads from the |repo|, (True | False).
    :type enable_downloads: bool
    :param fields: Add extra fields to the |repo|. Use the following
        example format: ``field_key=field_val,field_key2=fieldval2``.

docs/api/methods/server-methods.rst

@@ -1,7 +1,7 b''
 .. _server-methods-ref:
 
 server methods
-=================
+==============
 
 get_ip 
 ------

docs/api/methods/user-group-methods.rst

@@ -1,7 +1,7 b''
 .. _user-group-methods-ref:
 
 user_group methods
-=================
+==================
 
 add_user_to_user_group 
 ----------------------

docs/api/methods/user-methods.rst

@@ -1,12 +1,12 b''
 .. _user-methods-ref:
 
 user methods
-=================
+============
 
 create_user 
 -----------
 
-.. py:function:: create_user(apiuser, username, email, password=<Optional:''>, firstname=<Optional:''>, lastname=<Optional:''>, active=<Optional:True>, admin=<Optional:False>, extern_name=<Optional:'rhodecode'>, extern_type=<Optional:'rhodecode'>, force_password_change=<Optional:False>)
+.. py:function:: create_user(apiuser, username, email, password=<Optional:''>, firstname=<Optional:''>, lastname=<Optional:''>, active=<Optional:True>, admin=<Optional:False>, extern_name=<Optional:'rhodecode'>, extern_type=<Optional:'rhodecode'>, force_password_change=<Optional:False>, create_personal_repo_group=<Optional:None>)
 
    Creates a new user and returns the new user object.
 
@@ -39,7 +39,8 b' create_user'
    :param force_password_change: Force the new user to change password
        on next login.
    :type force_password_change: Optional(``True`` | ``False``)
-
+   :param create_personal_repo_group: Create personal repo group for this user
+   :type create_personal_repo_group: Optional(``True`` | ``False``)
    Example output:
 
    .. code-block:: bash
@@ -163,6 +164,7 b' get_user'
                "usergroup.read",
                "hg.repogroup.create.false",
                "hg.create.none",
+               "hg.password_reset.enabled",
                "hg.extern_activate.manual",
                "hg.create.write_on_repogroup.false",
                "hg.usergroup.create.false",

docs/contributing/api.rst

@@ -1,7 +1,7 b''
 
-=====
- API
-=====
+===================
+CONTRIBUTING TO API
+===================
 
 
 

docs/contributing/checklist-tickets.rst

@@ -130,7 +130,7 b' is a very small pencil which has to be c'
 ticket.
 
 
-.. figure:: images/redmine-description.png
+.. figure:: ../images/redmine-description.png
    :alt: Example of pencil to change the ticket description
 
    Shows an example of the pencil which lets you change the description.

docs/contributing/testing/spec-by-example.rst

@@ -9,9 +9,6 b''
 .. Avoid duplicating the quickstart instructions by importing the README
    file.
 
-.. include:: ../../../acceptance_tests/README.rst
-
-
 
 Choices of technology and tools
 ===============================

docs/default.nix

@@ -88,10 +88,10 b' let'
   };
 
   Sphinx = buildPythonPackage (rec {
-    name = "Sphinx-1.4.4";
+    name = "Sphinx-1.4.8";
     src = fetchurl {
-      url = "https://pypi.python.org/packages/20/a2/72f44c84f6c4115e3fef58d36d657ec311d80196eab9fd5ec7bcde76143b/${name}.tar.gz";
-      md5 = "64ce2ec08d37ed56313a98232cbe2aee";
+      url = "https://pypi.python.org/packages/1f/f6/e54a7aad73e35232356103771ae76306dadd8546b024c646fbe75135571c/${name}.tar.gz";
+      md5 = "5ec718a4855917e149498bba91b74e67";
     };
     propagatedBuildInputs = [
       docutils

docs/index.rst

@@ -20,8 +20,10 b' and commit files and |repos| while manag'
 * Migration from existing databases.
 * |RCM| SDK.
 * Built-in analytics
+* Built in integrations including: Slack, Jenkins, Webhooks, Jira, Redmine, Hipchat
 * Pluggable authentication system.
-* Support for |LDAP|, Crowd, CAS, PAM.
+* Support for AD, |LDAP|, Crowd, CAS, PAM.
+* Support for external authentication via Oauth Google, Github, Bitbucket, Twitter.
 * Debug modes of operation.
 * Private and public gists.
 * Gists with limited lifetimes and within instance only sharing.

docs/integrations/integrations.rst

@@ -50,3 +50,4 b' See pages specific to each type of integ'
    redmine
    jira
    webhook
+   email

docs/integrations/webhook.rst

@@ -7,6 +7,16 b' The Webhook integration allows you to PO'
 or pull requests to a custom http endpoint as a json dict with details of the
 event.
 
+Starting from 4.5.0 release, webhook integration allows to use variables
+inside the URL. For example in URL `https://server-example.com/${repo_name}`
+${repo_name} will be replaced with the name of repository which events is
+triggered from. Some of the variables like
+`${branch}` will result in webhook be called multiple times when multiple
+branches are pushed.
+
+Some of the variables like `${pull_request_id}` will be replaced only in
+the pull request related events.
+
 To create a webhook integration, select "webhook" in the integration settings
-and use the url and key from your custom webhook. See
-:ref:`creating-integrations` for additional instructions.
  No newline at end of file
+and use the URL and key from your any previous custom webhook created. See
+:ref:`creating-integrations` for additional instructions.

docs/release-notes/release-notes-4.3.0.rst

@@ -7,38 +7,6 b' Release Date'
 - 2016-08-12
 
 
-General
-^^^^^^^
-
-- Subversion: detect requests also based on magic path.
-  This adds subversion 1.9 support for SVN backend.
-- Summary/changelog: unified how data is displayed for those pages.
-    * use consistent order of columns
-    * fix the link to commit status
-    * fix order of displaying comments
-- Live-chat: refactor live chat system for code review based on
-  latest channelstream changes.
-- SVN: Add template to generate the apache mod_dav_svn config for all
-  repository groups. Repository groups can now be automatically mapped to be
-  supported by SVN backend. Set `svn.proxy.generate_config = true` and similar
-  options found inside .ini config.
-- Readme/markup: improved order of generating readme files. Fixes #4050
-    * we now use order based on default system renderer
-    * having multiple readme files will pick correct one as set renderer
-- Api: add a max_file_bytes parameter to get_nodes so that large files
-  can be skipped.
-- Auth-ldap: added flag to set debug mode for LDAP connections.
-- Labs: moved rebase-merge option from labs settings into VCS settings.
-- System: send platform type and version to upgrade endpoint when checking
-  for new versions.
-- Packaging: update rhodecode-tools from 0.8.3 to 0.10.0
-- Packaging: update codemirror from 5.4.0 to 5.11.0
-- Packaging: updated pygments to 2.1.3
-- Packaging: bumped supervisor to 3.3.0
-- Packaging: bumped psycopg2 to 2.6.1
-- Packaging: bumped mercurial to 3.8.4
-
-
 New Features
 ^^^^^^^^^^^^
 
@@ -64,6 +32,38 b' New Features'
   onto comments you submitted while doing a code-review.
 
 
+General
+^^^^^^^
+
+- Subversion: detect requests also based on magic path.
+  This adds subversion 1.9 support for SVN backend.
+- Summary/changelog: unified how data is displayed for those pages.
+    * use consistent order of columns
+    * fix the link to commit status
+    * fix order of displaying comments
+- Live chat: refactor live chat system for code review based on
+  latest channelstream changes.
+- SVN: Add template to generate the apache mod_dav_svn config for all
+  repository groups. Repository groups can now be automatically mapped to be
+  supported by SVN backend. Set `svn.proxy.generate_config = true` and similar
+  options found inside .ini config.
+- Readme/markup: improved order of generating readme files. Fixes #4050
+    * we now use order based on default system renderer
+    * having multiple readme files will pick correct one as set renderer
+- Api: add a max_file_bytes parameter to get_nodes so that large files
+  can be skipped.
+- Auth-ldap: added flag to set debug mode for LDAP connections.
+- Labs: moved rebase-merge option from labs settings into VCS settings.
+- System: send platform type and version to upgrade endpoint when checking
+  for new versions.
+- Packaging: update rhodecode-tools from 0.8.3 to 0.10.0
+- Packaging: update codemirror from 5.4.0 to 5.11.0
+- Packaging: updated pygments to 2.1.3
+- Packaging: bumped supervisor to 3.3.0
+- Packaging: bumped psycopg2 to 2.6.1
+- Packaging: bumped mercurial to 3.8.4
+
+
 Security
 ^^^^^^^^
 
@@ -105,7 +105,7 b' Fixes'
   support to gevent compatible handling.
 - Diff2way: fixed unicode problem on non-ascii files.
 - Full text search: whoosh schema uses now bigger ints, fixes #4035
-- File-browser: optimized cached tree calculation, reduced load times by
+- File browser: optimized cached tree calculation, reduced load times by
   50% on complex file trees.
 - Styling: #4086 fixing bug where long commit messages did not wrap in file view.
 - SVN: Ignore the content length header from response, fixes #4112.

docs/release-notes/release-notes-4.3.1.rst

@@ -6,6 +6,27 b' Release Date'
 
 - 2016-08-23
 
+
+New Features
+^^^^^^^^^^^^
+
+
+
+General
+^^^^^^^
+
+
+
+Security
+^^^^^^^^
+
+
+
+Performance
+^^^^^^^^^^^
+
+
+
 Fixes
 ^^^^^
 

docs/release-notes/release-notes-4.4.0.rst

@@ -7,18 +7,6 b' Release Date'
 - 2016-09-16
 
 
-General
-^^^^^^^
-
-- UI: introduced Polymer webcomponents into core application. RhodeCode will
-  be now shipped together with Polymer framework webcomponents. Most of
-  dynamic UI components that require large amounts of interaction
-  will be done now with Polymer.
-- live-notifications: use rhodecode-toast for live notifications instead of
-  toastr jquery plugin.
-- Svn: moved svn http support out of labs settings. It's tested and stable now.
-
-
 New Features
 ^^^^^^^^^^^^
 
@@ -29,11 +17,11 b' New Features'
   It will allow to configure exactly which projects use which integrations.
 - Integrations: show branches/commits separately when posting push events
   to hipchat/slack, fixes #4192.
-- Pull-requests: summary page now shows update dates for pull request to
+- Pull requests: summary page now shows update dates for pull request to
   easier see which one were receantly updated.
 - UI: hidden inline comments will be shown in side view when browsing the diffs
 - Diffs: added inline comments toggle into pull requests diff view. #2884
-- Live-chat: added summon reviewers functionality. You can now request
+- Live chat: added summon reviewers functionality. You can now request
   presence from online users into a chat for collaborative code-review.
   This requires channelstream to be enabled.
 - UX: added a static 502 page for gateway error. Once configured via
@@ -41,6 +29,18 b' New Features'
   backend servers are offline. Fixes #4202.
 
 
+General
+^^^^^^^
+
+- UI: introduced Polymer webcomponents into core application. RhodeCode will
+  be now shipped together with Polymer framework webcomponents. Most of
+  dynamic UI components that require large amounts of interaction
+  will be done now with Polymer.
+- Live notifications: use rhodecode-toast for live notifications instead of
+  toastr jquery plugin.
+- Svn: moved svn http support out of labs settings. It's tested and stable now.
+
+
 Security
 ^^^^^^^^
 
@@ -67,12 +67,12 b' Fixes'
   match rest of ui, fixes: #4200.
 - UX: show multiple tags/branches in changelog/summary instead of
   truncating them.
-- My-account: fix test notifications for IE10+
+- My account: fix test notifications for IE10+
 - Vcs: change way refs are retrieved for git so same name branch/tags and
   remotes can be supported, fixes #298.
 - Lexers: added small extensions table to extend syntax highlighting for file
   sources. Fixes #4227.
 - Search: fix bug where file path link was wrong when the repository name was
   in the file path, fixes #4228
-- Fixed INT overflow bug
+- Pagination: fixed INT overflow bug.
 - Events: send pushed commits always in the correct in order.

docs/release-notes/release-notes-4.4.1.rst

@@ -7,19 +7,18 b' Release Date'
 - 2016-09-27
 
 
+New Features
+^^^^^^^^^^^^
+
+
 General
 ^^^^^^^
 
-- channelstream: auto-generate the url to channelstream server if it's not
+- Channelstream: auto-generate the url to channelstream server if it's not
   explicitly defined in the config. It allows to use a relative server
   without knowing its address upfront.
 
 
-New Features
-^^^^^^^^^^^^
-
-
-
 Security
 ^^^^^^^^
 
@@ -34,7 +33,7 b' Fixes'
 ^^^^^
 
 - GIT: properly extract branches on events and submit them to integrations.
-- Pullrequests: fix problems with unicode in auto-generated descriptions
+- Pull requests: fix problems with unicode in auto-generated descriptions
 - Gist: fixed bug in update functionality of Gists that auto changed them
   to private.
 - SVN: add proper escaping in the autogenerated svn mod_dav config

docs/release-notes/release-notes-4.4.2.rst

@@ -7,21 +7,21 b' Release Date'
 - 2016-10-17
 
 
-General
-^^^^^^^
-
-- packaging: pinned against rhodecode-tools 0.10.1
-
-
 New Features
 ^^^^^^^^^^^^
 
 
 
+General
+^^^^^^^
+
+- Packaging: pinned against rhodecode-tools 0.10.1
+
+
 Security
 ^^^^^^^^
 
-- integrations: fix 500 error on integrations page when delegated admin
+- Integrations: fix 500 error on integrations page when delegated admin
   tried to access integration page after adding some integrations.
   Permission checks were to strict for delegated admins.
 
@@ -34,8 +34,8 b' Performance'
 Fixes
 ^^^^^
 
-- vcsserver: make sure we correctly ping against bundled HG/GIT/SVN binaries.
+- Vcsserver: make sure we correctly ping against bundled HG/GIT/SVN binaries.
   This should fix a problem where system binaries could be used accidentally
   by the RhodeCode.
-- ldap: fixed email extraction issues. Empty email addresses from LDAP server
+- LDAP: fixed email extraction issues. Empty email addresses from LDAP server
   will no longer take precedence over those stored inside RhodeCode database.

docs/release-notes/release-notes.rst

@@ -9,6 +9,7 b' Release Notes'
 .. toctree::
    :maxdepth: 1
 
+   release-notes-4.5.0.rst
    release-notes-4.4.2.rst
    release-notes-4.4.1.rst
    release-notes-4.4.0.rst

docs/tutorials/scaling-best-practices.rst

@@ -4,7 +4,7 b''
 Scaling Best Practices
 ======================
 
-When deploying |RCE| at scale; 100s of users, multiple instances, CI servers,
+When deploying |RCE| at scale; 1000s of users, multiple instances, CI servers,
 there are a number of steps you can take to ensure you are getting the
 most out of your system.
 
@@ -15,20 +15,23 b' You can configure multiple |RCE| instanc'
 set of |repos|. This lets users work on an instance that has less traffic
 than those being hit by CI servers. To configure this, use |RCC| to install
 multiple instances and configure the database and |repos| connection. If you
-do need to reset the database connection, see the
+do need to reset/adjust the database connection, see the
 :ref:`config-database` section.
 
-Once configured, set your CI servers to use a particular instance and for
-user specific instances you can configure loads balancing. See the
-:ref:`nginx-ws-ref` section for examples.
+You can configure then a load-balancer to balance the traffic between the CI
+dedicated instance and instance that end users would use.
+See the :ref:`nginx-ws-ref` section for examples on how to do it in NGINX.
 
 Switch to Database Sessions
 ---------------------------
 
-To increase database performance switch to database-based user sessions. In a
-large scale deployment, we recommend switching from file-based
-sessions to database-based user sessions. For configuration details, see the
-:ref:`db-session-ref` section.
+To increase |RCE| performance switch from the default file based sessions to
+database-based. In such way all your distributed instances would not need to
+share the file storage to use file-based sessions.
+Database based session have an additional advantage of the file
+based ones that they don't need a periodic cleanup as the session library
+cleans them up for users. For configuration details,
+see the :ref:`db-session-ref` section.
 
 Tuning |RCE|
 ------------

grunt_config.json

@@ -6,7 +6,9 b''
     },
     "js": {
       "src": "rhodecode/public/js/src",
-      "dest": "rhodecode/public/js"
+      "dest": "rhodecode/public/js",
+      "bower": "bower_components",
+      "node_modules": "node_modules"
     }
   },
   "copy": {
@@ -34,7 +36,8 b''
         "<%= dirs.js.src %>/bootstrap.js",
         "<%= dirs.js.src %>/mousetrap.js",
         "<%= dirs.js.src %>/moment.js",
-        "<%= dirs.js.src %>/appenlight-client-0.4.1.min.js",
+        "<%= dirs.js.node_modules %>/appenlight-client/appenlight-client.min.js",
+        "<%= dirs.js.node_modules %>/favico.js/favico-0.3.10.min.js",
         "<%= dirs.js.src %>/i18n_utils.js",
         "<%= dirs.js.src %>/deform.js",
         "<%= dirs.js.src %>/plugins/jquery.pjax.js",
@@ -64,7 +67,6 b''
         "<%= dirs.js.src %>/rhodecode/utils/ie.js",
         "<%= dirs.js.src %>/rhodecode/utils/os.js",
         "<%= dirs.js.src %>/rhodecode/utils/topics.js",
-        "<%= dirs.js.src %>/rhodecode/widgets/multiselect.js",
         "<%= dirs.js.src %>/rhodecode/init.js",
         "<%= dirs.js.src %>/rhodecode/codemirror.js",
         "<%= dirs.js.src %>/rhodecode/comments.js",
@@ -144,7 +146,9 b''
         "less:development",
         "less:components",
         "concat:polymercss",
-        "vulcanize"
+        "vulcanize",
+        "crisper",
+        "concat:dist"
       ]
     },
     "js": {

package.json

@@ -13,6 +13,8 b''
     "grunt-crisper": "^1.0.1",
     "grunt-vulcanize": "^1.0.0",
     "jshint": "^2.9.1-rc3",
-    "bower": "^1.7.9"
+    "bower": "^1.7.9",
+    "favico.js": "^0.3.10",
+    "appenlight-client": "git+https://[e-mail]/AppEnlight/appenlight-client-js.git#0.5.0"
   }
 }

pkgs/bower-packages.nix

@@ -4,10 +4,12 b' buildEnv { name = "bower-env"; ignoreCol'
   (fetchbower "polymer" "Polymer/polymer#1.6.1" "Polymer/polymer#^1.6.1" "09mm0jgk457gvwqlc155swch7gjr6fs3g7spnvhi6vh5b6518540")
   (fetchbower "paper-button" "PolymerElements/paper-button#1.0.13" "PolymerElements/paper-button#^1.0.13" "0i3y153nqk06pn0gk282vyybnl3g1w3w41d5i9z659cgn27g3fvm")
   (fetchbower "paper-spinner" "PolymerElements/paper-spinner#1.2.0" "PolymerElements/paper-spinner#^1.2.0" "1av1m6y81jw3hjhz1yqy3rwcgxarjzl58ldfn4q6sn51pgzngfqb")
-  (fetchbower "paper-tooltip" "PolymerElements/paper-tooltip#1.1.2" "PolymerElements/paper-tooltip#^1.1.2" "1j64nprcyk2d2bbl3qwjyr0lbjngm4wclpyfwgai1c4y6g6bigd2")
+  (fetchbower "paper-tooltip" "PolymerElements/paper-tooltip#1.1.3" "PolymerElements/paper-tooltip#^1.1.2" "0vmrm1n8k9sk9nvqy03q177axy22pia6i3j1gxbk72j3pqiqvg6k")
   (fetchbower "paper-toast" "PolymerElements/paper-toast#1.3.0" "PolymerElements/paper-toast#^1.3.0" "0x9rqxsks5455s8pk4aikpp99ijdn6kxr9gvhwh99nbcqdzcxq1m")
   (fetchbower "paper-toggle-button" "PolymerElements/paper-toggle-button#1.2.0" "PolymerElements/paper-toggle-button#^1.2.0" "0mphcng3ngspbpg4jjn0mb91nvr4xc1phq3qswib15h6sfww1b2w")
   (fetchbower "iron-ajax" "PolymerElements/iron-ajax#1.4.3" "PolymerElements/iron-ajax#^1.4.3" "0m3dx27arwmlcp00b7n516sc5a51f40p9vapr1nvd57l3i3z0pzm")
+  (fetchbower "iron-autogrow-textarea" "PolymerElements/iron-autogrow-textarea#1.0.13" "PolymerElements/iron-autogrow-textarea#^1.0.13" "0zwhpl97vii1s8k0lgain8i9dnw29b0mxc5ixdscx9las13n2lqq")
+  (fetchbower "iron-a11y-keys" "PolymerElements/iron-a11y-keys#1.0.6" "PolymerElements/iron-a11y-keys#^1.0.6" "1xz3mgghfcxixq28sdb654iaxj4nyi1bzcwf77ydkms6fviqs9mv")
   (fetchbower "iron-flex-layout" "PolymerElements/iron-flex-layout#1.3.1" "PolymerElements/iron-flex-layout#^1.0.0" "0nswv3ih3bhflgcd2wjfmddqswzgqxb2xbq65jk9w3rkj26hplbl")
   (fetchbower "paper-behaviors" "PolymerElements/paper-behaviors#1.0.12" "PolymerElements/paper-behaviors#^1.0.0" "012bqk97awgz55cn7rm9g7cckrdhkqhls3zvp8l6nd4rdwcrdzq8")
   (fetchbower "paper-material" "PolymerElements/paper-material#1.0.6" "PolymerElements/paper-material#^1.0.0" "0rljmknfdbm5aabvx9pk77754zckj3l127c3mvnmwkpkkr353xnh")
@@ -19,13 +21,13 b' buildEnv { name = "bower-env"; ignoreCol'
   (fetchbower "iron-checked-element-behavior" "PolymerElements/iron-checked-element-behavior#1.0.5" "PolymerElements/iron-checked-element-behavior#^1.0.0" "0l0yy4ah454s8bzfv076s8by7h67zy9ni6xb932qwyhx8br6c1m7")
   (fetchbower "promise-polyfill" "polymerlabs/promise-polyfill#1.0.1" "polymerlabs/promise-polyfill#^1.0.0" "045bj2caav3famr5hhxgs1dx7n08r4s46mlzwb313vdy17is38xb")
   (fetchbower "iron-behaviors" "PolymerElements/iron-behaviors#1.0.17" "PolymerElements/iron-behaviors#^1.0.0" "021qvkmbk32jrrmmphpmwgby4bzi5jyf47rh1bxmq2ip07ly4bpr")
+  (fetchbower "iron-validatable-behavior" "PolymerElements/iron-validatable-behavior#1.1.1" "PolymerElements/iron-validatable-behavior#^1.0.0" "1yhxlvywhw2klbbgm3f3cmanxfxggagph4ii635zv0c13707wslv")
+  (fetchbower "iron-form-element-behavior" "PolymerElements/iron-form-element-behavior#1.0.6" "PolymerElements/iron-form-element-behavior#^1.0.0" "0rdhxivgkdhhz2yadgdbjfc70l555p3y83vjh8rfj5hr0asyn6q1")
+  (fetchbower "iron-a11y-keys-behavior" "polymerelements/iron-a11y-keys-behavior#1.1.9" "polymerelements/iron-a11y-keys-behavior#^1.0.0" "1imm4gc84qizihhbyhfa8lwjh3myhj837f79i5m04xjgwrjmkaf6")
   (fetchbower "paper-ripple" "PolymerElements/paper-ripple#1.0.8" "PolymerElements/paper-ripple#^1.0.0" "0r9sq8ik7wwrw0qb82c3rw0c030ljwd3s466c9y4qbcrsbvfjnns")
   (fetchbower "font-roboto" "PolymerElements/font-roboto#1.0.1" "PolymerElements/font-roboto#^1.0.1" "02jz43r0wkyr3yp7rq2rc08l5cwnsgca9fr54sr4rhsnl7cjpxrj")
   (fetchbower "iron-meta" "PolymerElements/iron-meta#1.1.2" "PolymerElements/iron-meta#^1.0.0" "1wl4dx8fnsknw9z9xi8bpc4cy9x70c11x4zxwxnj73hf3smifppl")
   (fetchbower "iron-resizable-behavior" "PolymerElements/iron-resizable-behavior#1.0.5" "PolymerElements/iron-resizable-behavior#^1.0.0" "1fd5zmbr2hax42vmcasncvk7lzi38fmb1kyii26nn8pnnjak7zkn")
   (fetchbower "iron-selector" "PolymerElements/iron-selector#1.5.2" "PolymerElements/iron-selector#^1.0.0" "1ajv46llqzvahm5g6g75w7nfyjcslp53ji0wm96l2k94j87spv3r")
   (fetchbower "web-animations-js" "web-animations/web-animations-js#2.2.2" "web-animations/web-animations-js#^2.2.0" "1izfvm3l67vwys0bqbhidi9rqziw2f8wv289386sc6jsxzgkzhga")
-  (fetchbower "iron-a11y-keys-behavior" "PolymerElements/iron-a11y-keys-behavior#1.1.7" "PolymerElements/iron-a11y-keys-behavior#^1.0.0" "070z46dbbz242002gmqrgy28x0y1fcqp9hnvbi05r3zphiqfx3l7")
-  (fetchbower "iron-validatable-behavior" "PolymerElements/iron-validatable-behavior#1.1.1" "PolymerElements/iron-validatable-behavior#^1.0.0" "1yhxlvywhw2klbbgm3f3cmanxfxggagph4ii635zv0c13707wslv")
-  (fetchbower "iron-form-element-behavior" "PolymerElements/iron-form-element-behavior#1.0.6" "PolymerElements/iron-form-element-behavior#^1.0.0" "0rdhxivgkdhhz2yadgdbjfc70l555p3y83vjh8rfj5hr0asyn6q1")
 ]; }

pkgs/node-packages.nix

@@ -103,6 +103,34 b' let'
         sha1 = "a2e14ff85c2d6bf8c8080e5aa55129ebc6a2d320";
       };
     };
+    "bower-1.7.9" = {
+      name = "bower";
+      packageName = "bower";
+      version = "1.7.9";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/bower/-/bower-1.7.9.tgz";
+        sha1 = "b7296c2393e0d75edaa6ca39648132dd255812b0";
+      };
+    };
+    "favico.js-0.3.10" = {
+      name = "favico.js";
+      packageName = "favico.js";
+      version = "0.3.10";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/favico.js/-/favico.js-0.3.10.tgz";
+        sha1 = "80586e27a117f24a8d51c18a99bdc714d4339301";
+      };
+    };
+    "appenlight-client-git+https://[e-mail]/AppEnlight/appenlight-client-js.git#0.5.0" = {
+      name = "appenlight-client";
+      packageName = "appenlight-client";
+      version = "0.5.0";
+      src = fetchgit {
+        url = "https://[e-mail]/AppEnlight/appenlight-client-js.git";
+        rev = "b1d6853345dc3e96468b34537810b3eb77e0764f";
+        sha256 = "2ef00aef7dafdecdc1666d2e83fc190a796849985d04a8f0fad148d64aa4f8db";
+      };
+    };
     "async-0.1.22" = {
       name = "async";
       packageName = "async";
@@ -301,13 +329,13 b' let'
         sha1 = "fadd834b9683073da179b3eae6d9c0d15053f73e";
       };
     };
-    "inherits-2.0.1" = {
+    "inherits-2.0.3" = {
       name = "inherits";
       packageName = "inherits";
-      version = "2.0.1";
+      version = "2.0.3";
       src = fetchurl {
-        url = "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz";
-        sha1 = "b17d08d326b4423e568eff719f91b0b1cbdf69f1";
+        url = "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz";
+        sha1 = "633c2c83e3da42a502f52466022480f4208261de";
       };
     };
     "minimatch-0.3.0" = {
@@ -580,13 +608,13 b' let'
         sha1 = "6cbfea22b3b830304e9a5fb371d54fa480c9d7cf";
       };
     };
-    "lodash-4.15.0" = {
+    "lodash-4.16.2" = {
       name = "lodash";
       packageName = "lodash";
-      version = "4.15.0";
+      version = "4.16.2";
       src = fetchurl {
-        url = "https://registry.npmjs.org/lodash/-/lodash-4.15.0.tgz";
-        sha1 = "3162391d8f0140aa22cf8f6b3c34d6b7f63d3aa9";
+        url = "https://registry.npmjs.org/lodash/-/lodash-4.16.2.tgz";
+        sha1 = "3e626db827048a699281a8a125226326cfc0e652";
       };
     };
     "errno-0.1.4" = {
@@ -598,13 +626,13 b' let'
         sha1 = "b896e23a9e5e8ba33871fc996abd3635fc9a1c7d";
       };
     };
-    "graceful-fs-4.1.6" = {
+    "graceful-fs-4.1.8" = {
       name = "graceful-fs";
       packageName = "graceful-fs";
-      version = "4.1.6";
+      version = "4.1.8";
       src = fetchurl {
-        url = "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.6.tgz";
-        sha1 = "514c38772b31bee2e08bedc21a0aeb3abf54c19e";
+        url = "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.8.tgz";
+        sha1 = "da3e11135eb2168bdd374532c4e2649751672890";
       };
     };
     "image-size-0.5.0" = {
@@ -670,13 +698,13 b' let'
         sha1 = "857fcabfc3397d2625b8228262e86aa7a011b05d";
       };
     };
-    "asap-2.0.4" = {
+    "asap-2.0.5" = {
       name = "asap";
       packageName = "asap";
-      version = "2.0.4";
+      version = "2.0.5";
       src = fetchurl {
-        url = "https://registry.npmjs.org/asap/-/asap-2.0.4.tgz";
-        sha1 = "b391bf7f6bfbc65706022fec8f49c4b07fecf589";
+        url = "https://registry.npmjs.org/asap/-/asap-2.0.5.tgz";
+        sha1 = "522765b50c3510490e52d7dcfe085ef9ba96958f";
       };
     };
     "gaze-0.5.2" = {
@@ -778,13 +806,13 b' let'
         sha1 = "f197d6eaff34c9085577484b2864375b294f5697";
       };
     };
-    "dom5-1.3.3" = {
+    "dom5-1.3.6" = {
       name = "dom5";
       packageName = "dom5";
-      version = "1.3.3";
+      version = "1.3.6";
       src = fetchurl {
-        url = "https://registry.npmjs.org/dom5/-/dom5-1.3.3.tgz";
-        sha1 = "07e514522c245c7aa8512aa3f9118e8bcab9f909";
+        url = "https://registry.npmjs.org/dom5/-/dom5-1.3.6.tgz";
+        sha1 = "a7088a9fc5f3b08dc9f6eda4c7abaeb241945e0d";
       };
     };
     "array-back-1.0.3" = {
@@ -832,13 +860,13 b' let'
         sha1 = "a2d6ce740d15f0d92b1b26763e2ce9c0e361fd98";
       };
     };
-    "typical-2.5.0" = {
+    "typical-2.6.0" = {
       name = "typical";
       packageName = "typical";
-      version = "2.5.0";
+      version = "2.6.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/typical/-/typical-2.5.0.tgz";
-        sha1 = "81244918aa28180c9e602aa457173404be0604f1";
+        url = "https://registry.npmjs.org/typical/-/typical-2.6.0.tgz";
+        sha1 = "89d51554ab139848a65bcc2c8772f8fb450c40ed";
       };
     };
     "ansi-escape-sequences-2.2.2" = {
@@ -958,22 +986,22 b' let'
         sha1 = "a09136f72ec043d27c893707c2b159bfad7de93f";
       };
     };
-    "test-value-2.0.0" = {
+    "test-value-2.1.0" = {
       name = "test-value";
       packageName = "test-value";
-      version = "2.0.0";
+      version = "2.1.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/test-value/-/test-value-2.0.0.tgz";
-        sha1 = "0d65c45ee0b48a757c4507a5e98ec2680a9db137";
+        url = "https://registry.npmjs.org/test-value/-/test-value-2.1.0.tgz";
+        sha1 = "11da6ff670f3471a73b625ca4f3fdcf7bb748291";
       };
     };
-    "@types/clone-0.1.29" = {
+    "@types/clone-0.1.30" = {
       name = "@types/clone";
       packageName = "@types/clone";
-      version = "0.1.29";
+      version = "0.1.30";
       src = fetchurl {
-        url = "https://registry.npmjs.org/@types/clone/-/clone-0.1.29.tgz";
-        sha1 = "65a0be88189ffddcd373e450aa6b68c9c83218b7";
+        url = "https://registry.npmjs.org/@types/clone/-/clone-0.1.30.tgz";
+        sha1 = "e7365648c1b42136a59c7d5040637b3b5c83b614";
       };
     };
     "@types/node-4.0.30" = {
@@ -985,13 +1013,13 b' let'
         sha1 = "553f490ed3030311620f88003e7abfc0edcb301e";
       };
     };
-    "@types/parse5-0.0.28" = {
+    "@types/parse5-0.0.31" = {
       name = "@types/parse5";
       packageName = "@types/parse5";
-      version = "0.0.28";
+      version = "0.0.31";
       src = fetchurl {
-        url = "https://registry.npmjs.org/@types/parse5/-/parse5-0.0.28.tgz";
-        sha1 = "2a38cb7145bb157688d4ad2c46944c6dffae3cc6";
+        url = "https://registry.npmjs.org/@types/parse5/-/parse5-0.0.31.tgz";
+        sha1 = "e827a493a443b156e1b582a2e4c3bdc0040f2ee7";
       };
     };
     "clone-1.0.2" = {
@@ -1012,13 +1040,13 b' let'
         sha1 = "9b7f3b0de32be78dc2401b17573ccaf0f6f59d94";
       };
     };
-    "@types/node-6.0.37" = {
+    "@types/node-6.0.41" = {
       name = "@types/node";
       packageName = "@types/node";
-      version = "6.0.37";
+      version = "6.0.41";
       src = fetchurl {
-        url = "https://registry.npmjs.org/@types/node/-/node-6.0.37.tgz";
-        sha1 = "a1e081f2ec60074113d3a1fbf11f35d304f30e39";
+        url = "https://registry.npmjs.org/@types/node/-/node-6.0.41.tgz";
+        sha1 = "578cf53aaec65887bcaf16792f8722932e8ff8ea";
       };
     };
     "es6-promise-2.3.0" = {
@@ -1093,13 +1121,13 b' let'
         sha1 = "5a5b53af4693110bebb0867aa3430dd3b70a1018";
       };
     };
-    "espree-3.1.7" = {
+    "espree-3.3.1" = {
       name = "espree";
       packageName = "espree";
-      version = "3.1.7";
+      version = "3.3.1";
       src = fetchurl {
-        url = "https://registry.npmjs.org/espree/-/espree-3.1.7.tgz";
-        sha1 = "fd5deec76a97a5120a9cd3a7cb1177a0923b11d2";
+        url = "https://registry.npmjs.org/espree/-/espree-3.3.1.tgz";
+        sha1 = "42107376856738a65ff3b5877f3a58bd52497643";
       };
     };
     "estraverse-3.1.0" = {
@@ -1183,13 +1211,13 b' let'
         sha1 = "96e3b70d5779f6ad49cd032673d1c312767ba581";
       };
     };
-    "optionator-0.8.1" = {
+    "optionator-0.8.2" = {
       name = "optionator";
       packageName = "optionator";
-      version = "0.8.1";
+      version = "0.8.2";
       src = fetchurl {
-        url = "https://registry.npmjs.org/optionator/-/optionator-0.8.1.tgz";
-        sha1 = "e31b4932cdd5fb862a8b0d10bc63d3ee1ec7d78b";
+        url = "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz";
+        sha1 = "364c5e409d3f4d6301d6c0b4c05bba50180aeb64";
       };
     };
     "source-map-0.2.0" = {
@@ -1246,13 +1274,31 b' let'
         sha1 = "3b09924edf9f083c0490fdd4c0bc4421e04764ee";
       };
     };
-    "fast-levenshtein-1.1.4" = {
+    "fast-levenshtein-2.0.4" = {
       name = "fast-levenshtein";
       packageName = "fast-levenshtein";
-      version = "1.1.4";
+      version = "2.0.4";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.4.tgz";
+        sha1 = "e31e729eea62233c60a7bc9dce2bdcc88b4fffe3";
+      };
+    };
+    "acorn-4.0.3" = {
+      name = "acorn";
+      packageName = "acorn";
+      version = "4.0.3";
       src = fetchurl {
-        url = "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz";
-        sha1 = "e6a754cc8f15e58987aa9cbd27af66fd6f4e5af9";
+        url = "https://registry.npmjs.org/acorn/-/acorn-4.0.3.tgz";
+        sha1 = "1a3e850b428e73ba6b09d1cc527f5aaad4d03ef1";
+      };
+    };
+    "acorn-jsx-3.0.1" = {
+      name = "acorn-jsx";
+      packageName = "acorn-jsx";
+      version = "3.0.1";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz";
+        sha1 = "afdf9488fb1ecefc8348f6fb22f464e32a58b36b";
       };
     };
     "acorn-3.3.0" = {
@@ -1264,15 +1310,6 b' let'
         sha1 = "45e37fb39e8da3f25baee3ff5369e2bb5f22017a";
       };
     };
-    "acorn-jsx-3.0.1" = {
-      name = "acorn-jsx";
-      packageName = "acorn-jsx";
-      version = "3.0.1";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz";
-        sha1 = "afdf9488fb1ecefc8348f6fb22f464e32a58b36b";
-      };
-    };
     "boxen-0.3.1" = {
       name = "boxen";
       packageName = "boxen";
@@ -1282,13 +1319,13 b' let'
         sha1 = "a7d898243ae622f7abb6bb604d740a76c6a5461b";
       };
     };
-    "configstore-2.0.0" = {
+    "configstore-2.1.0" = {
       name = "configstore";
       packageName = "configstore";
-      version = "2.0.0";
+      version = "2.1.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/configstore/-/configstore-2.0.0.tgz";
-        sha1 = "8d81e9cdfa73ebd0e06bc985147856b2f1c4e764";
+        url = "https://registry.npmjs.org/configstore/-/configstore-2.1.0.tgz";
+        sha1 = "737a3a7036e9886102aa6099e47bb33ab1aba1a1";
       };
     };
     "is-npm-1.0.0" = {
@@ -1399,13 +1436,13 b' let'
         sha1 = "ef9e31386f031a7f0d643af82fde50c457ef00cb";
       };
     };
-    "dot-prop-2.4.0" = {
+    "dot-prop-3.0.0" = {
       name = "dot-prop";
       packageName = "dot-prop";
-      version = "2.4.0";
+      version = "3.0.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/dot-prop/-/dot-prop-2.4.0.tgz";
-        sha1 = "848e28f7f1d50740c6747ab3cb07670462b6f89c";
+        url = "https://registry.npmjs.org/dot-prop/-/dot-prop-3.0.0.tgz";
+        sha1 = "1b708af094a49c9a0e7dbcad790aba539dac1177";
       };
     };
     "os-tmpdir-1.0.1" = {
@@ -1426,13 +1463,13 b' let'
         sha1 = "83cf05c6d6458fc4d5ac6362ea325d92f2754217";
       };
     };
-    "uuid-2.0.2" = {
+    "uuid-2.0.3" = {
       name = "uuid";
       packageName = "uuid";
-      version = "2.0.2";
+      version = "2.0.3";
       src = fetchurl {
-        url = "https://registry.npmjs.org/uuid/-/uuid-2.0.2.tgz";
-        sha1 = "48bd5698f0677e3c7901a1c46ef15b1643794726";
+        url = "https://registry.npmjs.org/uuid/-/uuid-2.0.3.tgz";
+        sha1 = "67e2e863797215530dff318e5bf9dcebfd47b21a";
       };
     };
     "write-file-atomic-1.2.0" = {
@@ -1489,13 +1526,13 b' let'
         sha1 = "56eb027d65b4d2dce6cb2e2d32c4d4afc9e1d707";
       };
     };
-    "package-json-2.3.3" = {
+    "package-json-2.4.0" = {
       name = "package-json";
       packageName = "package-json";
-      version = "2.3.3";
+      version = "2.4.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/package-json/-/package-json-2.3.3.tgz";
-        sha1 = "14895311a963d18edf8801e06b67ea87795d15b9";
+        url = "https://registry.npmjs.org/package-json/-/package-json-2.4.0.tgz";
+        sha1 = "0d15bd67d1cbbddbb2ca222ff2edb86bcb31a8bb";
       };
     };
     "got-5.6.0" = {
@@ -1507,13 +1544,13 b' let'
         sha1 = "bb1d7ee163b78082bbc8eb836f3f395004ea6fbf";
       };
     };
-    "rc-1.1.6" = {
-      name = "rc";
-      packageName = "rc";
-      version = "1.1.6";
+    "registry-auth-token-3.0.1" = {
+      name = "registry-auth-token";
+      packageName = "registry-auth-token";
+      version = "3.0.1";
       src = fetchurl {
-        url = "https://registry.npmjs.org/rc/-/rc-1.1.6.tgz";
-        sha1 = "43651b76b6ae53b5c802f1151fa3fc3b059969c9";
+        url = "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-3.0.1.tgz";
+        sha1 = "c3ee5ec585bce29f88bf41629a3944c71ed53e25";
       };
     };
     "registry-url-3.1.0" = {
@@ -1651,13 +1688,13 b' let'
         sha1 = "f38b0ae81d3747d628001f41dafc652ace671c0a";
       };
     };
-    "unzip-response-1.0.0" = {
+    "unzip-response-1.0.1" = {
       name = "unzip-response";
       packageName = "unzip-response";
-      version = "1.0.0";
+      version = "1.0.1";
       src = fetchurl {
-        url = "https://registry.npmjs.org/unzip-response/-/unzip-response-1.0.0.tgz";
-        sha1 = "bfda54eeec658f00c2df4d4494b9dca0ca00f3e4";
+        url = "https://registry.npmjs.org/unzip-response/-/unzip-response-1.0.1.tgz";
+        sha1 = "4a73959f2989470fa503791cefb54e1dbbc68412";
       };
     };
     "url-parse-lax-1.0.0" = {
@@ -1768,6 +1805,15 b' let'
         sha1 = "d4f4562b0ce3696e41ac52d0e002e57a635dc6dc";
       };
     };
+    "rc-1.1.6" = {
+      name = "rc";
+      packageName = "rc";
+      version = "1.1.6";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/rc/-/rc-1.1.6.tgz";
+        sha1 = "43651b76b6ae53b5c802f1151fa3fc3b059969c9";
+      };
+    };
     "ini-1.3.4" = {
       name = "ini";
       packageName = "ini";
@@ -1858,13 +1904,13 b' let'
         sha1 = "3678bd8ab995057c07ade836ed2ef087da811d45";
       };
     };
-    "glob-7.0.6" = {
+    "glob-7.1.0" = {
       name = "glob";
       packageName = "glob";
-      version = "7.0.6";
+      version = "7.1.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/glob/-/glob-7.0.6.tgz";
-        sha1 = "211bafaf49e525b8cd93260d14ab136152b3f57a";
+        url = "https://registry.npmjs.org/glob/-/glob-7.1.0.tgz";
+        sha1 = "36add856d746d0d99e4cc2797bba1ae2c67272fd";
       };
     };
     "fs.realpath-1.0.0" = {
@@ -1885,13 +1931,13 b' let'
         sha1 = "db3204cd5a9de2e6cd890b85c6e2f66bcf4f620a";
       };
     };
-    "once-1.3.3" = {
+    "once-1.4.0" = {
       name = "once";
       packageName = "once";
-      version = "1.3.3";
+      version = "1.4.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/once/-/once-1.3.3.tgz";
-        sha1 = "b2e261557ce4c314ec8304f3fa82663e4297ca20";
+        url = "https://registry.npmjs.org/once/-/once-1.4.0.tgz";
+        sha1 = "583b1aa775961d4b113ac17d9c50baef9dd76bd1";
       };
     };
     "wrappy-1.0.2" = {
@@ -2034,7 +2080,7 b' let'
       (sources."grunt-contrib-less-1.4.0" // {
         dependencies = [
           sources."async-2.0.1"
-          sources."lodash-4.15.0"
+          sources."lodash-4.16.2"
         ];
       })
       (sources."grunt-contrib-watch-0.6.1" // {
@@ -2062,6 +2108,9 b' let'
           sources."lodash-3.7.0"
         ];
       })
+      sources."bower-1.7.9"
+      sources."favico.js-0.3.10"
+      sources."appenlight-client-git+https://[e-mail]/AppEnlight/appenlight-client-js.git#0.5.0"
       sources."async-0.1.22"
       sources."coffee-script-1.3.3"
       sources."colors-0.6.2"
@@ -2097,7 +2146,7 b' let'
           sources."underscore.string-2.3.3"
         ];
       })
-      sources."inherits-2.0.1"
+      sources."inherits-2.0.3"
       sources."lru-cache-2.7.3"
       sources."sigmund-1.0.1"
       sources."graceful-fs-1.2.3"
@@ -2127,7 +2176,7 b' let'
       sources."amdefine-1.0.0"
       (sources."less-2.7.1" // {
         dependencies = [
-          sources."graceful-fs-4.1.6"
+          sources."graceful-fs-4.1.8"
           sources."source-map-0.5.6"
         ];
       })
@@ -2138,7 +2187,7 b' let'
       sources."promise-7.1.1"
       sources."prr-0.0.0"
       sources."minimist-0.0.8"
-      sources."asap-2.0.4"
+      sources."asap-2.0.5"
       sources."gaze-0.5.2"
       sources."tiny-lr-fork-0.0.5"
       (sources."globule-0.1.0" // {
@@ -2155,17 +2204,17 b' let'
       })
       sources."debug-0.7.4"
       sources."command-line-args-2.1.6"
-      sources."dom5-1.3.3"
+      sources."dom5-1.3.6"
       sources."array-back-1.0.3"
       sources."command-line-usage-2.0.5"
       sources."core-js-2.4.1"
       sources."feature-detect-es6-1.3.1"
       (sources."find-replace-1.0.2" // {
         dependencies = [
-          sources."test-value-2.0.0"
+          sources."test-value-2.1.0"
         ];
       })
-      sources."typical-2.5.0"
+      sources."typical-2.6.0"
       sources."ansi-escape-sequences-2.2.2"
       sources."column-layout-2.1.4"
       sources."wordwrapjs-1.2.1"
@@ -2182,11 +2231,11 b' let'
       sources."object-tools-2.0.6"
       sources."object-get-2.1.0"
       sources."test-value-1.1.0"
-      sources."@types/clone-0.1.29"
+      sources."@types/clone-0.1.30"
       sources."@types/node-4.0.30"
-      (sources."@types/parse5-0.0.28" // {
+      (sources."@types/parse5-0.0.31" // {
         dependencies = [
-          sources."@types/node-6.0.37"
+          sources."@types/node-6.0.41"
         ];
       })
       sources."clone-1.0.2"
@@ -2205,26 +2254,30 b' let'
           sources."source-map-0.2.0"
         ];
       })
-      sources."espree-3.1.7"
+      sources."espree-3.3.1"
       sources."estraverse-3.1.0"
       sources."path-is-absolute-1.0.0"
       sources."babel-runtime-6.11.6"
       sources."regenerator-runtime-0.9.5"
       sources."esutils-1.1.6"
       sources."isarray-0.0.1"
-      sources."optionator-0.8.1"
+      sources."optionator-0.8.2"
       sources."prelude-ls-1.1.2"
       sources."deep-is-0.1.3"
       sources."wordwrap-1.0.0"
       sources."type-check-0.3.2"
       sources."levn-0.3.0"
-      sources."fast-levenshtein-1.1.4"
-      sources."acorn-3.3.0"
-      sources."acorn-jsx-3.0.1"
+      sources."fast-levenshtein-2.0.4"
+      sources."acorn-4.0.3"
+      (sources."acorn-jsx-3.0.1" // {
+        dependencies = [
+          sources."acorn-3.3.0"
+        ];
+      })
       sources."boxen-0.3.1"
-      (sources."configstore-2.0.0" // {
+      (sources."configstore-2.1.0" // {
         dependencies = [
-          sources."graceful-fs-4.1.6"
+          sources."graceful-fs-4.1.8"
         ];
       })
       sources."is-npm-1.0.0"
@@ -2239,13 +2292,13 b' let'
       sources."number-is-nan-1.0.0"
       sources."code-point-at-1.0.0"
       sources."is-fullwidth-code-point-1.0.0"
-      sources."dot-prop-2.4.0"
+      sources."dot-prop-3.0.0"
       sources."os-tmpdir-1.0.1"
       sources."osenv-0.1.3"
-      sources."uuid-2.0.2"
+      sources."uuid-2.0.3"
       (sources."write-file-atomic-1.2.0" // {
         dependencies = [
-          sources."graceful-fs-4.1.6"
+          sources."graceful-fs-4.1.8"
         ];
       })
       sources."xdg-basedir-2.0.0"
@@ -2253,13 +2306,9 b' let'
       sources."os-homedir-1.0.1"
       sources."imurmurhash-0.1.4"
       sources."slide-1.1.6"
-      sources."package-json-2.3.3"
+      sources."package-json-2.4.0"
       sources."got-5.6.0"
-      (sources."rc-1.1.6" // {
-        dependencies = [
-          sources."minimist-1.2.0"
-        ];
-      })
+      sources."registry-auth-token-3.0.1"
       sources."registry-url-3.1.0"
       sources."semver-5.3.0"
       sources."create-error-class-3.0.2"
@@ -2279,7 +2328,7 b' let'
         ];
       })
       sources."timed-out-2.0.0"
-      sources."unzip-response-1.0.0"
+      sources."unzip-response-1.0.1"
       sources."url-parse-lax-1.0.0"
       sources."capture-stack-trace-1.0.0"
       sources."error-ex-1.3.0"
@@ -2291,11 +2340,16 b' let'
       sources."string_decoder-0.10.31"
       sources."util-deprecate-1.0.2"
       sources."prepend-http-1.0.4"
+      (sources."rc-1.1.6" // {
+        dependencies = [
+          sources."minimist-1.2.0"
+        ];
+      })
       sources."ini-1.3.4"
       sources."strip-json-comments-1.0.4"
       (sources."cli-1.0.0" // {
         dependencies = [
-          sources."glob-7.0.6"
+          sources."glob-7.1.0"
           sources."minimatch-3.0.3"
         ];
       })
@@ -2308,7 +2362,7 b' let'
       sources."shelljs-0.3.0"
       sources."fs.realpath-1.0.0"
       sources."inflight-1.0.5"
-      sources."once-1.3.3"
+      sources."once-1.4.0"
       sources."wrappy-1.0.2"
       sources."brace-expansion-1.1.6"
       sources."balanced-match-0.4.2"

pkgs/python-packages-overrides.nix

@@ -15,19 +15,6 b' let'
     };
   };
 
-  # johbo: Interim bridge which allows us to build with the upcoming
-  # nixos.16.09 branch (unstable at the moment of writing this note) and the
-  # current stable nixos-16.03.
-  backwardsCompatibleFetchgit = { ... }@args:
-    let
-      origSources = pkgs.fetchgit args;
-    in
-    pkgs.lib.overrideDerivation origSources (oldAttrs: {
-      NIX_PREFETCH_GIT_CHECKOUT_HOOK = ''
-        find $out -name '.git*' -print0 | xargs -0 rm -rf
-      '';
-    });
-
 in
 
 self: super: {
@@ -77,6 +64,9 b' self: super: {'
   });
 
   lxml = super.lxml.override (attrs: {
+    # johbo: On 16.09 we need this to compile on darwin, otherwise compilation
+    # fails on Darwin.
+    hardeningDisable = if pkgs.stdenv.isDarwin then [ "format" ] else null;
     buildInputs = with self; [
       pkgs.libxml2
       pkgs.libxslt
@@ -110,7 +100,7 b' self: super: {'
   });
 
   py-gfm = super.py-gfm.override  {
-    src = backwardsCompatibleFetchgit {
+    src = pkgs.fetchgit {
       url = "https://code.rhodecode.com/upstream/py-gfm";
       rev = "0d66a19bc16e3d49de273c0f797d4e4781e8c0f2";
       sha256 = "0ryp74jyihd3ckszq31bml5jr3bciimhfp7va7kw6ld92930ksv3";
@@ -134,7 +124,7 b' self: super: {'
 
   Pylons = super.Pylons.override (attrs: {
     name = "Pylons-1.0.1-patch1";
-    src = backwardsCompatibleFetchgit {
+    src = pkgs.fetchgit {
       url = "https://code.rhodecode.com/upstream/pylons";
       rev = "707354ee4261b9c10450404fc9852ccea4fd667d";
       sha256 = "b2763274c2780523a335f83a1df65be22ebe4ff413a7bc9e9288d23c1f62032e";
@@ -190,7 +180,8 b' self: super: {'
       pkgs.openldap
       pkgs.openssl
     ];
-    NIX_CFLAGS_COMPILE = "-I${pkgs.cyrus_sasl}/include/sasl";
+    # TODO: johbo: Remove the "or" once we drop 16.03 support.
+    NIX_CFLAGS_COMPILE = "-I${pkgs.cyrus_sasl.dev or pkgs.cyrus_sasl}/include/sasl";
   });
 
   python-pam = super.python-pam.override (attrs:

pkgs/python-packages.nix

@@ -431,6 +431,19 b''
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
+  backports.shutil-get-terminal-size = super.buildPythonPackage {
+    name = "backports.shutil-get-terminal-size-1.0.0";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/ec/9c/368086faa9c016efce5da3e0e13ba392c9db79e3ab740b763fe28620b18b/backports.shutil_get_terminal_size-1.0.0.tar.gz";
+      md5 = "03267762480bd86b50580dc19dff3c66";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
   bottle = super.buildPythonPackage {
     name = "bottle-0.12.8";
     buildInputs = with self; [];
@@ -678,17 +691,17 b''
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
-  flake8 = super.buildPythonPackage {
-    name = "flake8-2.4.1";
+  enum34 = super.buildPythonPackage {
+    name = "enum34-1.1.6";
     buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [pyflakes pep8 mccabe];
+    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/8f/b5/9a73c66c7dba273bac8758398f060c008a25f3e84531063b42503b5d0a95/flake8-2.4.1.tar.gz";
-      md5 = "ed45d3db81a3b7c88bd63c6e37ca1d65";
+      url = "https://pypi.python.org/packages/bf/3e/31d502c25302814a7c2f1d3959d2a3b3f78e509002ba91aea64993936876/enum34-1.1.6.tar.gz";
+      md5 = "5f13a0841a61f7fc295c514490d120d0";
     };
     meta = {
-      license = [ pkgs.lib.licenses.mit ];
+      license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   future = super.buildPythonPackage {
@@ -809,26 +822,39 b''
     };
   };
   ipdb = super.buildPythonPackage {
-    name = "ipdb-0.8";
+    name = "ipdb-0.10.1";
     buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [ipython];
+    propagatedBuildInputs = with self; [ipython setuptools];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/f0/25/d7dd430ced6cd8dc242a933c8682b5dbf32eb4011d82f87e34209e5ec845/ipdb-0.8.zip";
-      md5 = "96dca0712efa01aa5eaf6b22071dd3ed";
+      url = "https://pypi.python.org/packages/eb/0a/0a37dc19572580336ad3813792c0d18c8d7117c2d66fc63c501f13a7a8f8/ipdb-0.10.1.tar.gz";
+      md5 = "4aeab65f633ddc98ebdb5eebf08dc713";
     };
     meta = {
-      license = [ pkgs.lib.licenses.gpl1 ];
+      license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   ipython = super.buildPythonPackage {
-    name = "ipython-3.1.0";
+    name = "ipython-5.1.0";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [setuptools decorator pickleshare simplegeneric traitlets prompt-toolkit Pygments pexpect backports.shutil-get-terminal-size pathlib2 pexpect];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/89/63/a9292f7cd9d0090a0f995e1167f3f17d5889dcbc9a175261719c513b9848/ipython-5.1.0.tar.gz";
+      md5 = "47c8122420f65b58784cb4b9b4af35e3";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  ipython-genutils = super.buildPythonPackage {
+    name = "ipython-genutils-0.1.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/06/91/120c0835254c120af89f066afaabf81289bc2726c1fc3ca0555df6882f58/ipython-3.1.0.tar.gz";
-      md5 = "a749d90c16068687b0ec45a27e72ef8f";
+      url = "https://pypi.python.org/packages/71/b7/a64c71578521606edbbce15151358598f3dfb72a3431763edc2baf19e71f/ipython_genutils-0.1.0.tar.gz";
+      md5 = "9a8afbe0978adbcbfcb3b35b2d015a56";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
@@ -886,19 +912,6 b''
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  mccabe = super.buildPythonPackage {
-    name = "mccabe-0.3";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/c9/2e/75231479e11a906b64ac43bad9d0bb534d00080b18bdca8db9da46e1faf7/mccabe-0.3.tar.gz";
-      md5 = "81640948ff226f8c12b3277059489157";
-    };
-    meta = {
-      license = [ { fullName = "Expat license"; } pkgs.lib.licenses.mit ];
-    };
-  };
   meld3 = super.buildPythonPackage {
     name = "meld3-1.0.2";
     buildInputs = with self; [];
@@ -990,17 +1003,17 b''
       license = [ { fullName = "LGPL"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
     };
   };
-  pep8 = super.buildPythonPackage {
-    name = "pep8-1.5.7";
+  pathlib2 = super.buildPythonPackage {
+    name = "pathlib2-2.1.0";
     buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = with self; [six];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/8b/de/259f5e735897ada1683489dd514b2a1c91aaa74e5e6b68f80acf128a6368/pep8-1.5.7.tar.gz";
-      md5 = "f6adbdd69365ecca20513c709f9b7c93";
+      url = "https://pypi.python.org/packages/c9/27/8448b10d8440c08efeff0794adf7d0ed27adb98372c70c7b38f3947d4749/pathlib2-2.1.0.tar.gz";
+      md5 = "38e4f58b4d69dfcb9edb49a54a8b28d2";
     };
     meta = {
-      license = [ { fullName = "Expat license"; } pkgs.lib.licenses.mit ];
+      license = [ pkgs.lib.licenses.mit ];
     };
   };
   peppercorn = super.buildPythonPackage {
@@ -1016,14 +1029,53 b''
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
+  pexpect = super.buildPythonPackage {
+    name = "pexpect-4.2.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [ptyprocess];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/e8/13/d0b0599099d6cd23663043a2a0bb7c61e58c6ba359b2656e6fb000ef5b98/pexpect-4.2.1.tar.gz";
+      md5 = "3694410001a99dff83f0b500a1ca1c95";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.isc { fullName = "ISC License (ISCL)"; } ];
+    };
+  };
+  pickleshare = super.buildPythonPackage {
+    name = "pickleshare-0.7.4";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [pathlib2];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/69/fe/dd137d84daa0fd13a709e448138e310d9ea93070620c9db5454e234af525/pickleshare-0.7.4.tar.gz";
+      md5 = "6a9e5dd8dfc023031f6b7b3f824cab12";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  prompt-toolkit = super.buildPythonPackage {
+    name = "prompt-toolkit-1.0.9";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [six wcwidth];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/83/14/5ac258da6c530eca02852ee25c7a9ff3ca78287bb4c198d0d0055845d856/prompt_toolkit-1.0.9.tar.gz";
+      md5 = "a39f91a54308fb7446b1a421c11f227c";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
   psutil = super.buildPythonPackage {
-    name = "psutil-2.2.1";
+    name = "psutil-4.3.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/df/47/ee54ef14dd40f8ce831a7581001a5096494dc99fe71586260ca6b531fe86/psutil-2.2.1.tar.gz";
-      md5 = "1a2b58cd9e3a53528bb6148f0c4d5244";
+      url = "https://pypi.python.org/packages/78/cc/f267a1371f229bf16db6a4e604428c3b032b823b83155bd33cef45e49a53/psutil-4.3.1.tar.gz";
+      md5 = "199a366dba829c88bddaf5b41d19ddc0";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
@@ -1042,6 +1094,19 b''
       license = [ pkgs.lib.licenses.zpt21 { fullName = "GNU Library or Lesser General Public License (LGPL)"; } { fullName = "LGPL with exceptions or ZPL"; } ];
     };
   };
+  ptyprocess = super.buildPythonPackage {
+    name = "ptyprocess-0.5.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/db/d7/b465161910f3d1cef593c5e002bff67e0384898f597f1a7fdc8db4c02bf6/ptyprocess-0.5.1.tar.gz";
+      md5 = "94e537122914cc9ec9c1eadcd36e73a1";
+    };
+    meta = {
+      license = [  ];
+    };
+  };
   py = super.buildPythonPackage {
     name = "py-1.4.29";
     buildInputs = with self; [];
@@ -1120,6 +1185,19 b''
       license = [ pkgs.lib.licenses.mit ];
     };
   };
+  pygments-markdown-lexer = super.buildPythonPackage {
+    name = "pygments-markdown-lexer-0.1.0.dev39";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [Pygments];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/c3/12/674cdee66635d638cedb2c5d9c85ce507b7b2f91bdba29e482f1b1160ff6/pygments-markdown-lexer-0.1.0.dev39.zip";
+      md5 = "6360fe0f6d1f896e35b7a0142ce6459c";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.asl20 ];
+    };
+  };
   pyparsing = super.buildPythonPackage {
     name = "pyparsing-1.5.7";
     buildInputs = with self; [];
@@ -1420,10 +1498,10 b''
     };
   };
   rhodecode-enterprise-ce = super.buildPythonPackage {
-    name = "rhodecode-enterprise-ce-4.4.2";
-    buildInputs = with self; [WebTest configobj cssselect flake8 lxml mock pytest pytest-cov pytest-runner];
+    name = "rhodecode-enterprise-ce-4.5.0";
+    buildInputs = with self; [WebTest configobj cssselect lxml mock pytest pytest-cov pytest-runner pytest-sugar];
     doCheck = true;
-    propagatedBuildInputs = with self; [Babel Beaker FormEncode Mako Markdown MarkupSafe MySQL-python Paste PasteDeploy PasteScript Pygments Pylons Pyro4 Routes SQLAlchemy Tempita URLObject WebError WebHelpers WebHelpers2 WebOb WebTest Whoosh alembic amqplib anyjson appenlight-client authomatic backport-ipaddress celery channelstream colander decorator deform docutils gevent gunicorn infrae.cache ipython iso8601 kombu msgpack-python packaging psycopg2 py-gfm pycrypto pycurl pyparsing pyramid pyramid-debugtoolbar pyramid-mako pyramid-beaker pysqlite python-dateutil python-ldap python-memcached python-pam recaptcha-client repoze.lru requests simplejson waitress zope.cachedescriptors dogpile.cache dogpile.core psutil py-bcrypt];
+    propagatedBuildInputs = with self; [Babel Beaker FormEncode Mako Markdown MarkupSafe MySQL-python Paste PasteDeploy PasteScript Pygments pygments-markdown-lexer Pylons Pyro4 Routes SQLAlchemy Tempita URLObject WebError WebHelpers WebHelpers2 WebOb WebTest Whoosh alembic amqplib anyjson appenlight-client authomatic backport-ipaddress celery channelstream colander decorator deform docutils gevent gunicorn infrae.cache ipython iso8601 kombu msgpack-python packaging psycopg2 py-gfm pycrypto pycurl pyparsing pyramid pyramid-debugtoolbar pyramid-mako pyramid-beaker pysqlite python-dateutil python-ldap python-memcached python-pam recaptcha-client repoze.lru requests simplejson subprocess32 waitress zope.cachedescriptors dogpile.cache dogpile.core psutil py-bcrypt];
     src = ./.;
     meta = {
       license = [ { fullName = "AGPLv3, and Commercial License"; } ];
@@ -1494,6 +1572,19 b''
       license = [ pkgs.lib.licenses.mit ];
     };
   };
+  simplegeneric = super.buildPythonPackage {
+    name = "simplegeneric-0.8.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/3d/57/4d9c9e3ae9a255cd4e1106bb57e24056d3d0709fc01b2e3e345898e49d5b/simplegeneric-0.8.1.zip";
+      md5 = "f9c1fab00fd981be588fc32759f474e3";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.zpt21 ];
+    };
+  };
   simplejson = super.buildPythonPackage {
     name = "simplejson-3.7.2";
     buildInputs = with self; [];
@@ -1546,6 +1637,19 b''
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
+  traitlets = super.buildPythonPackage {
+    name = "traitlets-4.3.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [ipython-genutils six decorator enum34];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/b1/d6/5b5aa6d5c474691909b91493da1e8972e309c9f01ecfe4aeafd272eb3234/traitlets-4.3.1.tar.gz";
+      md5 = "dd0b1b6e5d31ce446d55a4b5e5083c98";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
   transifex-client = super.buildPythonPackage {
     name = "transifex-client-0.10";
     buildInputs = with self; [];
@@ -1637,6 +1741,19 b''
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
+  wcwidth = super.buildPythonPackage {
+    name = "wcwidth-0.1.7";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/55/11/e4a2bb08bb450fdbd42cc709dd40de4ed2c472cf0ccb9e64af22279c5495/wcwidth-0.1.7.tar.gz";
+      md5 = "b3b6a0a08f0c8a34d1de8cf44150a4ad";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
   ws4py = super.buildPythonPackage {
     name = "ws4py-0.3.5";
     buildInputs = with self; [];
@@ -1718,5 +1835,30 b''
 
 ### Test requirements
 
-  
+  pytest-sugar = super.buildPythonPackage {
+    name = "pytest-sugar-0.7.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [pytest termcolor];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/03/97/05d988b4fa870e7373e8ee4582408543b9ca2bd35c3c67b569369c6f9c49/pytest-sugar-0.7.1.tar.gz";
+      md5 = "7400f7c11f3d572b2c2a3b60352d35fe";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  termcolor = super.buildPythonPackage {
+    name = "termcolor-1.1.0";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/8a/48/a76be51647d0eb9f10e2a4511bf3ffb8cc1e6b14e9e4fab46173aa79f981/termcolor-1.1.0.tar.gz";
+      md5 = "043e89644f8909d462fbbfa511c768df";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
 }

pytest.ini

@@ -1,9 +1,9 b''
 [pytest]
 testpaths = ./rhodecode
-pylons_config = test.ini
-vcsserver_protocol = pyro4
-vcsserver_config = rhodecode/tests/vcsserver.ini
-vcsserver_config_http = rhodecode/tests/vcsserver_pyramid.ini
+pylons_config = rhodecode/tests/rhodecode.ini
+vcsserver_protocol = http
+vcsserver_config_pyro4 = rhodecode/tests/vcsserver_pyro4.ini
+vcsserver_config_http = rhodecode/tests/vcsserver_http.ini
 norecursedirs = tests/scripts
 addopts = -k "not _BaseTest"
 markers =

requirements.txt

@@ -1,5 +1,6 b''
 Babel==1.3
 Beaker==1.7.0
+Chameleon==2.24
 CProfileV==1.0.6
 FormEncode==1.2.4
 Jinja2==2.7.3
@@ -11,6 +12,7 b' Paste==2.0.2'
 PasteDeploy==1.5.2
 PasteScript==1.7.5
 Pygments==2.1.3
+pygments-markdown-lexer==0.1.0.dev39
 
 # TODO: This version is not available on PyPI
 # Pylons==1.0.2.dev20160108
@@ -62,7 +64,6 b' dogpile.cache==0.6.1'
 dogpile.core==0.4.1
 dulwich==0.12.0
 ecdsa==0.11
-flake8==2.4.1
 future==0.14.3
 futures==3.0.2
 gevent==1.1.1
@@ -77,13 +78,12 b' gunicorn==19.6.0'
 gnureadline==6.3.3
 infrae.cache==1.0.1
 invoke==0.13.0
-ipdb==0.8
-ipython==3.1.0
+ipdb==0.10.1
+ipython==5.1.0
 iso8601==0.1.11
 itsdangerous==0.24
 kombu==1.5.1
 lxml==3.4.4
-mccabe==0.3
 meld3==1.0.2
 mock==1.0.1
 msgpack-python==0.4.6
@@ -91,8 +91,7 b' nose==1.3.6'
 objgraph==2.0.0
 packaging==15.2
 paramiko==1.15.1
-pep8==1.5.7
-psutil==2.2.1
+psutil==4.3.1
 psycopg2==2.6.1
 py==1.4.29
 py-bcrypt==0.4
@@ -141,6 +140,7 b' transifex-client==0.10'
 translationstring==1.3
 trollius==1.0.4
 uWSGI==2.0.11.2
+urllib3==1.16
 venusian==1.0
 waitress==0.8.9
 wsgiref==0.1.2

rhodecode/VERSION

@@ -1,1 +1,1 b''
-4.4.2
  No newline at end of file
+4.5.0
  No newline at end of file

rhodecode/__init__.py

@@ -51,7 +51,7 b' PYRAMID_SETTINGS = {}'
 EXTENSIONS = {}
 
 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
-__dbversion__ = 58  # defines current db version for migrations
+__dbversion__ = 63  # defines current db version for migrations
 __platform__ = platform.system()
 __license__ = 'AGPLv3, and Commercial License'
 __author__ = 'RhodeCode GmbH'

rhodecode/admin/__init__.py

@@ -35,6 +35,9 b' def includeme(config):'
     config.add_route(
         name='admin_settings_open_source',
         pattern=ADMIN_PREFIX + '/settings/open_source')
+    config.add_route(
+        name='admin_settings_vcs_svn_generate_cfg',
+        pattern=ADMIN_PREFIX + '/settings/vcs/svn_generate_cfg')
 
     # Scan module for configuration decorators.
     config.scan()

rhodecode/admin/views.py

@@ -24,8 +24,11 b' import logging'
 from pylons import tmpl_context as c
 from pyramid.view import view_config
 
-from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
+from rhodecode.lib.auth import (
+    LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib.utils import read_opensource_licenses
+from rhodecode.svn_support.utils import generate_mod_dav_svn_config
+from rhodecode.translation import _
 
 from .navigation import navigation_list
 
@@ -53,3 +56,27 b' class AdminSettingsView(object):'
             sorted(read_opensource_licenses().items(), key=lambda t: t[0]))
 
         return {}
+
+    @LoginRequired()
+    @CSRFRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_vcs_svn_generate_cfg',
+        request_method='POST', renderer='json')
+    def vcs_svn_generate_config(self):
+        try:
+            generate_mod_dav_svn_config(self.request.registry)
+            msg = {
+                'message': _('Apache configuration for Subversion generated.'),
+                'level': 'success',
+            }
+        except Exception:
+            log.exception(
+                'Exception while generating the Apache configuration for Subversion.')
+            msg = {
+                'message': _('Failed to generate the Apache configuration for Subversion.'),
+                'level': 'error',
+            }
+
+        data = {'message': msg}
+        return data

rhodecode/api/tests/test_create_repo.py

@@ -23,8 +23,11 b' import json'
 import mock
 import pytest
 
+from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs import settings
+from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
@@ -36,29 +39,37 b' fixture = Fixture()'
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateRepo(object):
-    def test_api_create_repo(self, backend):
-        repo_name = 'api-repo-1'
+
+    @pytest.mark.parametrize('given, expected_name, expected_exc', [
+        ('api repo-1', 'api-repo-1', False),
+        ('api-repo 1-ąć', 'api-repo-1-ąć', False),
+        (u'unicode-ąć', u'unicode-ąć', False),
+        ('some repo v1.2', 'some-repo-v1.2', False),
+        ('v2.0', 'v2.0', False),
+    ])
+    def test_api_create_repo(self, backend, given, expected_name, expected_exc):
+
         id_, params = build_data(
             self.apikey,
             'create_repo',
-            repo_name=repo_name,
+            repo_name=given,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
         )
         response = api_call(self.app, params)
 
-        repo = RepoModel().get_by_repo_name(repo_name)
-
-        assert repo is not None
         ret = {
-            'msg': 'Created new repository `%s`' % (repo_name,),
+            'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
-        id_, params = build_data(self.apikey, 'get_repo', repoid=repo_name)
+        repo = RepoModel().get_by_repo_name(safe_unicode(expected_name))
+        assert repo is not None
+
+        id_, params = build_data(self.apikey, 'get_repo', repoid=expected_name)
         response = api_call(self.app, params)
         body = json.loads(response.body)
 
@@ -66,7 +77,7 b' class TestCreateRepo(object):'
         assert body['result']['enable_locking'] is False
         assert body['result']['enable_statistics'] is False
 
-        fixture.destroy_repo(repo_name)
+        fixture.destroy_repo(safe_unicode(expected_name))
 
     def test_api_create_restricted_repo_type(self, backend):
         repo_name = 'api-repo-type-{0}'.format(backend.alias)
@@ -158,6 +169,21 b' class TestCreateRepo(object):'
         fixture.destroy_repo(repo_name)
         fixture.destroy_repo_group(repo_group_name)
 
+    def test_create_repo_in_group_that_doesnt_exist(self, backend, user_util):
+        repo_group_name = 'fake_group'
+
+        repo_name = '%s/api-repo-gr' % (repo_group_name,)
+        id_, params = build_data(
+            self.apikey, 'create_repo',
+            repo_name=repo_name,
+            owner=TEST_USER_ADMIN_LOGIN,
+            repo_type=backend.alias,)
+        response = api_call(self.app, params)
+
+        expected = {'repo_group': 'Repository group `{}` does not exist'.format(
+            repo_group_name)}
+        assert_error(id_, expected, given=response.body)
+
     def test_api_create_repo_unknown_owner(self, backend):
         repo_name = 'api-repo-2'
         owner = 'i-dont-exist'
@@ -218,10 +244,48 b' class TestCreateRepo(object):'
             owner=owner)
         response = api_call(self.app, params)
 
-        expected = 'Only RhodeCode admin can specify `owner` param'
+        expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
+    def test_api_create_repo_by_non_admin_no_parent_group_perms(self, backend):
+        repo_group_name = 'no-access'
+        fixture.create_repo_group(repo_group_name)
+        repo_name = 'no-access/api-repo'
+
+        id_, params = build_data(
+            self.apikey_regular, 'create_repo',
+            repo_name=repo_name,
+            repo_type=backend.alias)
+        response = api_call(self.app, params)
+
+        expected = {'repo_group': 'Repository group `{}` does not exist'.format(
+            repo_group_name)}
+        assert_error(id_, expected, given=response.body)
+        fixture.destroy_repo_group(repo_group_name)
+        fixture.destroy_repo(repo_name)
+
+    def test_api_create_repo_non_admin_no_permission_to_create_to_root_level(
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+
+        repo_name = backend.new_repo_name()
+        id_, params = build_data(
+            regular_user_api_key, 'create_repo',
+            repo_name=repo_name,
+            repo_type=backend.alias)
+        response = api_call(self.app, params)
+        expected = {
+            "repo_name": "You do not have the permission to "
+                         "store repositories in the root location."}
+        assert_error(id_, expected, given=response.body)
+
     def test_api_create_repo_exists(self, backend):
         repo_name = backend.repo_name
         id_, params = build_data(
@@ -230,7 +294,9 b' class TestCreateRepo(object):'
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
-        expected = "repo `%s` already exist" % (repo_name,)
+        expected = {
+            'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                repo_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create', crash)
@@ -245,26 +311,40 b' class TestCreateRepo(object):'
         expected = 'failed to create repository `%s`' % (repo_name,)
         assert_error(id_, expected, given=response.body)
 
-    def test_create_repo_with_extra_slashes_in_name(self, backend, user_util):
-        existing_repo_group = user_util.create_repo_group()
-        dirty_repo_name = '//{}/repo_name//'.format(
-            existing_repo_group.group_name)
-        cleaned_repo_name = '{}/repo_name'.format(
-            existing_repo_group.group_name)
+    @pytest.mark.parametrize('parent_group, dirty_name, expected_name', [
+        (None, 'foo bar x', 'foo-bar-x'),
+        ('foo', '/foo//bar x', 'foo/bar-x'),
+        ('foo-bar', 'foo-bar //bar x', 'foo-bar/bar-x'),
+    ])
+    def test_create_repo_with_extra_slashes_in_name(
+            self, backend, parent_group, dirty_name, expected_name):
+
+        if parent_group:
+            gr = fixture.create_repo_group(parent_group)
+            assert gr.group_name == parent_group
 
         id_, params = build_data(
             self.apikey, 'create_repo',
-            repo_name=dirty_repo_name,
+            repo_name=dirty_name,
             repo_type=backend.alias,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
-        repo = RepoModel().get_by_repo_name(cleaned_repo_name)
+        expected ={
+           "msg": "Created new repository `{}`".format(expected_name),
+           "task": None,
+           "success": True
+        }
+        assert_ok(id_, expected, response.body)
+
+        repo = RepoModel().get_by_repo_name(expected_name)
         assert repo is not None
 
         expected = {
-            'msg': 'Created new repository `%s`' % (cleaned_repo_name,),
+            'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         assert_ok(id_, expected, given=response.body)
-        fixture.destroy_repo(cleaned_repo_name)
+        fixture.destroy_repo(expected_name)
+        if parent_group:
+            fixture.destroy_repo_group(parent_group)

rhodecode/api/tests/test_create_repo_group.py

@@ -54,55 +54,10 b' class TestCreateRepoGroup(object):'
             'repo_group': repo_group.get_api_data()
         }
         expected = ret
-        assert_ok(id_, expected, given=response.body)
-        fixture.destroy_repo_group(repo_group_name)
-
-    def test_api_create_repo_group_regular_user(self):
-        repo_group_name = 'api-repo-group'
-
-        usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
-        usr.inherit_default_permissions = False
-        Session().add(usr)
-        UserModel().grant_perm(
-            self.TEST_USER_LOGIN, 'hg.repogroup.create.true')
-        Session().commit()
-
-        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
-        assert repo_group is None
-
-        id_, params = build_data(
-            self.apikey_regular, 'create_repo_group',
-            group_name=repo_group_name,
-            owner=TEST_USER_ADMIN_LOGIN,)
-        response = api_call(self.app, params)
-
-        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
-        assert repo_group is not None
-        ret = {
-            'msg': 'Created new repo group `%s`' % (repo_group_name,),
-            'repo_group': repo_group.get_api_data()
-        }
-        expected = ret
-        assert_ok(id_, expected, given=response.body)
-        fixture.destroy_repo_group(repo_group_name)
-        UserModel().revoke_perm(
-            self.TEST_USER_LOGIN, 'hg.repogroup.create.true')
-        usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
-        usr.inherit_default_permissions = True
-        Session().add(usr)
-        Session().commit()
-
-    def test_api_create_repo_group_regular_user_no_permission(self):
-        repo_group_name = 'api-repo-group'
-
-        id_, params = build_data(
-            self.apikey_regular, 'create_repo_group',
-            group_name=repo_group_name,
-            owner=TEST_USER_ADMIN_LOGIN,)
-        response = api_call(self.app, params)
-
-        expected = "Access was denied to this resource."
-        assert_error(id_, expected, given=response.body)
+        try:
+            assert_ok(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_in_another_group(self):
         repo_group_name = 'api-repo-group'
@@ -127,9 +82,11 b' class TestCreateRepoGroup(object):'
             'repo_group': repo_group.get_api_data()
         }
         expected = ret
-        assert_ok(id_, expected, given=response.body)
-        fixture.destroy_repo_group(full_repo_group_name)
-        fixture.destroy_repo_group(repo_group_name)
+        try:
+            assert_ok(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(full_repo_group_name)
+            fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_in_another_group_not_existing(self):
         repo_group_name = 'api-repo-group-no'
@@ -144,7 +101,10 b' class TestCreateRepoGroup(object):'
             owner=TEST_USER_ADMIN_LOGIN,
             copy_permissions=True)
         response = api_call(self.app, params)
-        expected = 'repository group `%s` does not exist' % (repo_group_name,)
+        expected = {
+            'repo_group':
+                'Parent repository group `{}` does not exist'.format(
+                    repo_group_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_group_that_exists(self):
@@ -159,9 +119,139 b' class TestCreateRepoGroup(object):'
             group_name=repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
-        expected = 'repo group `%s` already exist' % (repo_group_name,)
+        expected = {
+            'unique_repo_group_name':
+                'Repository group with name `{}` already exists'.format(
+                    repo_group_name)}
+        try:
+            assert_error(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(repo_group_name)
+
+    def test_api_create_repo_group_regular_user_wit_root_location_perms(
+            self, user_util):
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+
+        repo_group_name = 'api-repo-group-by-regular-user'
+
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+
+        UserModel().grant_perm(
+            regular_user.username, 'hg.repogroup.create.true')
+        Session().commit()
+
+        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
+        assert repo_group is None
+
+        id_, params = build_data(
+            regular_user_api_key, 'create_repo_group',
+            group_name=repo_group_name)
+        response = api_call(self.app, params)
+
+        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
+        assert repo_group is not None
+        expected = {
+            'msg': 'Created new repo group `%s`' % (repo_group_name,),
+            'repo_group': repo_group.get_api_data()
+        }
+        try:
+            assert_ok(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(repo_group_name)
+
+    def test_api_create_repo_group_regular_user_with_admin_perms_to_parent(
+            self, user_util):
+
+        repo_group_name = 'api-repo-group-parent'
+
+        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
+        assert repo_group is None
+        # create the parent
+        fixture.create_repo_group(repo_group_name)
+
+        # user perms
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+
+        RepoGroupModel().grant_user_permission(
+            repo_group_name, regular_user.username, 'group.admin')
+        Session().commit()
+
+        full_repo_group_name = repo_group_name + '/' + repo_group_name
+        id_, params = build_data(
+            regular_user_api_key, 'create_repo_group',
+            group_name=full_repo_group_name)
+        response = api_call(self.app, params)
+
+        repo_group = RepoGroupModel.cls.get_by_group_name(full_repo_group_name)
+        assert repo_group is not None
+        expected = {
+            'msg': 'Created new repo group `{}`'.format(full_repo_group_name),
+            'repo_group': repo_group.get_api_data()
+        }
+        try:
+            assert_ok(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(full_repo_group_name)
+            fixture.destroy_repo_group(repo_group_name)
+
+    def test_api_create_repo_group_regular_user_no_permission_to_create_to_root_level(self):
+        repo_group_name = 'api-repo-group'
+
+        id_, params = build_data(
+            self.apikey_regular, 'create_repo_group',
+            group_name=repo_group_name)
+        response = api_call(self.app, params)
+
+        expected = {
+            'repo_group':
+                u'You do not have the permission to store '
+                u'repository groups in the root location.'}
         assert_error(id_, expected, given=response.body)
-        fixture.destroy_repo_group(repo_group_name)
+
+    def test_api_create_repo_group_regular_user_no_parent_group_perms(self):
+        repo_group_name = 'api-repo-group-regular-user'
+
+        repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
+        assert repo_group is None
+        # create the parent
+        fixture.create_repo_group(repo_group_name)
+
+        full_repo_group_name = repo_group_name+'/'+repo_group_name
+
+        id_, params = build_data(
+            self.apikey_regular, 'create_repo_group',
+            group_name=full_repo_group_name)
+        response = api_call(self.app, params)
+
+        expected = {
+            'repo_group':
+                'Parent repository group `{}` does not exist'.format(
+                    repo_group_name)}
+        try:
+            assert_error(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(repo_group_name)
+
+    def test_api_create_repo_group_regular_user_no_permission_to_specify_owner(
+            self):
+        repo_group_name = 'api-repo-group'
+
+        id_, params = build_data(
+            self.apikey_regular, 'create_repo_group',
+            group_name=repo_group_name,
+            owner=TEST_USER_ADMIN_LOGIN,)
+        response = api_call(self.app, params)
+
+        expected = "Only RhodeCode super-admin can specify `owner` param"
+        assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'create', crash)
     def test_api_create_repo_group_exception_occurred(self):

rhodecode/api/tests/test_create_user.py

@@ -28,6 +28,7 b' from rhodecode.tests import ('
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, jsonify, crash)
 from rhodecode.tests.fixture import Fixture
+from rhodecode.model.db import RepoGroup
 
 
 # TODO: mikhail: remove fixture from here
@@ -145,6 +146,36 b' class TestCreateUser(object):'
         finally:
             fixture.destroy_user(usr.user_id)
 
+    def test_api_create_user_with_personal_repo_group(self):
+        username = 'test_new_api_user_personal_group'
+        email = username + "@foo.com"
+
+        id_, params = build_data(
+            self.apikey, 'create_user',
+            username=username,
+            email=email, extern_name='rhodecode',
+            create_personal_repo_group=True)
+        response = api_call(self.app, params)
+
+        usr = UserModel().get_by_username(username)
+        ret = {
+            'msg': 'created new user `%s`' % (username,),
+            'user': jsonify(usr.get_api_data(include_secrets=True)),
+        }
+
+        personal_group = RepoGroup.get_by_group_name(username)
+        assert personal_group
+        assert personal_group.personal == True
+        assert personal_group.user.username == username
+
+        try:
+            expected = ret
+            assert_ok(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo_group(username)
+            fixture.destroy_user(usr.user_id)
+
+
     @mock.patch.object(UserModel, 'create_or_update', crash)
     def test_api_create_user_when_exception_happened(self):
 

rhodecode/api/tests/test_fork_repo.py

@@ -24,6 +24,7 b' import pytest'
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
@@ -99,11 +100,35 b' class TestApiForkRepo(object):'
         finally:
             fixture.destroy_repo(fork_name)
 
+    def test_api_fork_repo_non_admin_into_group_no_permission(self, backend, user_util):
+        source_name = backend['minimal'].repo_name
+        repo_group = user_util.create_repo_group()
+        repo_group_name = repo_group.group_name
+        fork_name = '%s/api-repo-fork' % repo_group_name
+
+        id_, params = build_data(
+            self.apikey_regular, 'fork_repo',
+            repoid=source_name,
+            fork_name=fork_name)
+        response = api_call(self.app, params)
+
+        expected = {
+            'repo_group': 'Repository group `{}` does not exist'.format(
+                repo_group_name)}
+        try:
+            assert_error(id_, expected, given=response.body)
+        finally:
+            fixture.destroy_repo(fork_name)
+
     def test_api_fork_repo_non_admin_into_group(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         fork_name = '%s/api-repo-fork' % repo_group.group_name
 
+        RepoGroupModel().grant_user_permission(
+            repo_group, self.TEST_USER_LOGIN, 'group.admin')
+        Session().commit()
+
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
@@ -129,10 +154,11 b' class TestApiForkRepo(object):'
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
-        expected = 'Only RhodeCode admin can specify `owner` param'
+        expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
 
-    def test_api_fork_repo_non_admin_no_permission_to_fork(self, backend):
+    def test_api_fork_repo_non_admin_no_permission_of_source_repo(
+            self, backend):
         source_name = backend['minimal'].repo_name
         RepoModel().grant_user_permission(repo=source_name,
                                           user=self.TEST_USER_LOGIN,
@@ -147,19 +173,44 b' class TestApiForkRepo(object):'
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork_to_root_level(
-            self, backend):
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+        usr = UserModel().get_by_username(regular_user.username)
+        usr.inherit_default_permissions = False
+        Session().add(usr)
+        UserModel().grant_perm(regular_user.username, 'hg.fork.repository')
+
         source_name = backend['minimal'].repo_name
+        fork_name = backend.new_repo_name()
+        id_, params = build_data(
+            regular_user_api_key, 'fork_repo',
+            repoid=source_name,
+            fork_name=fork_name)
+        response = api_call(self.app, params)
+        expected = {
+            "repo_name": "You do not have the permission to "
+                         "store repositories in the root location."}
+        assert_error(id_, expected, given=response.body)
 
-        usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
+    def test_api_fork_repo_non_admin_no_permission_to_fork(
+            self, backend, user_util):
+
+        regular_user = user_util.create_user()
+        regular_user_api_key = regular_user.api_key
+        usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
+        source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
-            self.apikey_regular, 'fork_repo',
+            regular_user_api_key, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
+
         expected = "Access was denied to this resource."
         assert_error(id_, expected, given=response.body)
 
@@ -189,7 +240,9 b' class TestApiForkRepo(object):'
         response = api_call(self.app, params)
 
         try:
-            expected = "fork `%s` already exist" % (fork_name,)
+            expected = {
+                'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                    fork_name)}
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_repo.repo_name)
@@ -205,7 +258,9 b' class TestApiForkRepo(object):'
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
-        expected = "repo `%s` already exist" % (fork_name,)
+        expected = {
+            'unique_repo_name': 'Repository with name `{}` already exists'.format(
+                fork_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create_fork', crash)

rhodecode/api/tests/test_get_pull_request.py

@@ -34,6 +34,7 b' pytestmark = pytest.mark.backends("git",'
 class TestGetPullRequest(object):
 
     def test_api_get_pull_request(self, pr_util):
+        from rhodecode.model.pull_request import PullRequestModel
         pull_request = pr_util.create_pull_request(mergeable=True)
         id_, params = build_data(
             self.apikey, 'get_pull_request',
@@ -57,6 +58,8 b' class TestGetPullRequest(object):'
         target_url = unicode(
             pull_request.target_repo.clone_url()
                 .with_netloc('test.example.com:80'))
+        shadow_url = unicode(
+            PullRequestModel().get_shadow_clone_url(pull_request))
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'url': pr_url,
@@ -89,15 +92,24 b' class TestGetPullRequest(object):'
                     'commit_id': pull_request.target_ref_parts.commit_id,
                 },
             },
+            'merge': {
+                'clone_url': shadow_url,
+                'reference': {
+                    'name': pull_request.shadow_merge_ref.name,
+                    'type': pull_request.shadow_merge_ref.type,
+                    'commit_id': pull_request.shadow_merge_ref.commit_id,
+                },
+            },
             'author': pull_request.author.get_api_data(include_secrets=False,
                                                        details='basic'),
             'reviewers': [
                 {
                     'user': reviewer.get_api_data(include_secrets=False,
                                                   details='basic'),
+                    'reasons': reasons,
                     'review_status': st[0][1].status if st else 'not_reviewed',
                 }
-                for reviewer, st in pull_request.reviewers_statuses()
+                for reviewer, reasons, st in pull_request.reviewers_statuses()
             ]
         }
         assert_ok(id_, expected, response.body)

rhodecode/api/tests/test_get_server_info.py

@@ -45,8 +45,13 b' class TestGetServerInfo(object):'
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
-        expected['disk'] = resp['result']['disk']
-        expected['server_ip'] = '127.0.0.1:80'
+        expected['storage'] = resp['result']['storage']
+        expected['storage_temp'] = resp['result']['storage_temp']
+        expected['storage_inodes'] = resp['result']['storage_inodes']
+        expected['server'] = resp['result']['server']
+
+        expected['index_storage'] = resp['result']['index_storage']
+        expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
 
@@ -59,7 +64,21 b' class TestGetServerInfo(object):'
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
-        expected['disk'] = resp['result']['disk']
-        expected['server_ip'] = '127.0.0.1:80'
+        expected['storage'] = resp['result']['storage']
+        expected['storage_temp'] = resp['result']['storage_temp']
+        expected['storage_inodes'] = resp['result']['storage_inodes']
+        expected['server'] = resp['result']['server']
+
+        expected['index_storage'] = resp['result']['index_storage']
+        expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
+
+    def test_api_get_server_info_data_for_search_index_build(self):
+        id_, params = build_data(self.apikey, 'get_server_info')
+        response = api_call(self.app, params)
+        resp = response.json
+
+        # required by indexer
+        assert resp['result']['index_storage']
+        assert resp['result']['storage']

rhodecode/api/tests/test_merge_pull_request.py

@@ -32,42 +32,37 b' from rhodecode.api.tests.utils import ('
 class TestMergePullRequest(object):
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request(self, pr_util, no_notifications):
-        pull_request = pr_util.create_pull_request()
-        pull_request_2 = PullRequestModel().create(
-            created_by=pull_request.author,
-            source_repo=pull_request.source_repo,
-            source_ref=pull_request.source_ref,
-            target_repo=pull_request.target_repo,
-            target_ref=pull_request.target_ref,
-            revisions=pull_request.revisions,
-            reviewers=(),
-            title=pull_request.title,
-            description=pull_request.description,
-        )
+        pull_request = pr_util.create_pull_request(mergeable=True)
         author = pull_request.user_id
-        repo = pull_request_2.target_repo.repo_id
-        pull_request_2_id = pull_request_2.pull_request_id
-        pull_request_2_repo = pull_request_2.target_repo.repo_name
-        Session().commit()
+        repo = pull_request.target_repo.repo_id
+        pull_request_id = pull_request.pull_request_id
+        pull_request_repo = pull_request.target_repo.repo_name
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
-            repoid=pull_request_2_repo,
-            pullrequestid=pull_request_2_id)
+            repoid=pull_request_repo,
+            pullrequestid=pull_request_id)
+
         response = api_call(self.app, params)
 
+        # The above api call detaches the pull request DB object from the
+        # session because of an unconditional transaction rollback in our
+        # middleware. Therefore we need to add it back here if we want to use
+        # it.
+        Session().add(pull_request)
+
         expected = {
             'executed': True,
             'failure_reason': 0,
-            'possible': True
+            'possible': True,
+            'merge_commit_id': pull_request.shadow_merge_ref.commit_id,
+            'merge_ref': pull_request.shadow_merge_ref._asdict()
         }
 
         response_json = response.json['result']
-        assert response_json['merge_commit_id']
-        response_json.pop('merge_commit_id')
         assert response_json == expected
 
-        action = 'user_merged_pull_request:%d' % (pull_request_2_id, )
+        action = 'user_merged_pull_request:%d' % (pull_request_id, )
         journal = UserLog.query()\
             .filter(UserLog.user_id == author)\
             .filter(UserLog.repository_id == repo)\
@@ -77,11 +72,11 b' class TestMergePullRequest(object):'
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
-            repoid=pull_request_2_repo, pullrequestid=pull_request_2_id)
+            repoid=pull_request_repo, pullrequestid=pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'pull request `%s` merge failed, pull request is closed' % (
-            pull_request_2_id)
+            pull_request_id)
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")

rhodecode/api/tests/test_update_repo.py

@@ -32,35 +32,60 b' fixture = Fixture()'
 
 UPDATE_REPO_NAME = 'api_update_me'
 
-class SAME_AS_UPDATES(object): """ Constant used for tests below """
+
+class SAME_AS_UPDATES(object):
+    """ Constant used for tests below """
+
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepo(object):
 
     @pytest.mark.parametrize("updates, expected", [
-        ({'owner': TEST_USER_REGULAR_LOGIN}, SAME_AS_UPDATES),
-        ({'description': 'new description'}, SAME_AS_UPDATES),
-        ({'clone_uri': 'http://foo.com/repo'}, SAME_AS_UPDATES),
-        ({'clone_uri': None}, {'clone_uri': ''}),
-        ({'clone_uri': ''}, {'clone_uri': ''}),
-        ({'landing_rev': 'branch:master'}, {'landing_rev': ['branch','master']}),
-        ({'enable_statistics': True}, SAME_AS_UPDATES),
-        ({'enable_locking': True}, SAME_AS_UPDATES),
-        ({'enable_downloads': True}, SAME_AS_UPDATES),
-        ({'name': 'new_repo_name'}, {
+        ({'owner': TEST_USER_REGULAR_LOGIN},
+         SAME_AS_UPDATES),
+
+        ({'description': 'new description'},
+         SAME_AS_UPDATES),
+
+        ({'clone_uri': 'http://foo.com/repo'},
+         SAME_AS_UPDATES),
+
+        ({'clone_uri': None},
+         {'clone_uri': ''}),
+
+        ({'clone_uri': ''},
+         {'clone_uri': ''}),
+
+        ({'landing_rev': 'rev:tip'},
+         {'landing_rev': ['rev', 'tip']}),
+
+        ({'enable_statistics': True},
+         SAME_AS_UPDATES),
+
+        ({'enable_locking': True},
+         SAME_AS_UPDATES),
+
+        ({'enable_downloads': True},
+         SAME_AS_UPDATES),
+
+        ({'repo_name': 'new_repo_name'},
+         {
             'repo_name': 'new_repo_name',
-            'url': 'http://test.example.com:80/new_repo_name',
-        }),
-        ({'group': 'test_group_for_update'}, {
-            'repo_name': 'test_group_for_update/%s' % UPDATE_REPO_NAME,
-            'url': 'http://test.example.com:80/test_group_for_update/%s' % UPDATE_REPO_NAME
-        }),
+            'url': 'http://test.example.com:80/new_repo_name'
+         }),
+
+        ({'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
+          '_group': 'test_group_for_update'},
+         {
+            'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
+            'url': 'http://test.example.com:80/test_group_for_update/{}'.format(UPDATE_REPO_NAME)
+         }),
     ])
     def test_api_update_repo(self, updates, expected, backend):
         repo_name = UPDATE_REPO_NAME
         repo = fixture.create_repo(repo_name, repo_type=backend.alias)
-        if updates.get('group'):
-            fixture.create_repo_group(updates['group'])
+        if updates.get('_group'):
+            fixture.create_repo_group(updates['_group'])
 
         expected_api_data = repo.get_api_data(include_secrets=True)
         if expected is SAME_AS_UPDATES:
@@ -68,15 +93,12 b' class TestApiUpdateRepo(object):'
         else:
             expected_api_data.update(expected)
 
-
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
 
-        if updates.get('name'):
-            repo_name = updates['name']
-        if updates.get('group'):
-            repo_name = '/'.join([updates['group'], repo_name])
+        if updates.get('repo_name'):
+            repo_name = updates['repo_name']
 
         try:
             expected = {
@@ -86,8 +108,8 b' class TestApiUpdateRepo(object):'
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
-            if updates.get('group'):
-                fixture.destroy_repo_group(updates['group'])
+            if updates.get('_group'):
+                fixture.destroy_repo_group(updates['_group'])
 
     def test_api_update_repo_fork_of_field(self, backend):
         master_repo = backend.create_repo()
@@ -118,19 +140,23 b' class TestApiUpdateRepo(object):'
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
-        expected = 'repository `{}` does not exist'.format(master_repo_name)
+        expected = {
+            'repo_fork_of': 'Fork with id `{}` does not exists'.format(
+                master_repo_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_with_repo_group_not_existing(self):
         repo_name = 'admin_owned'
+        fake_repo_group = 'test_group_for_update'
         fixture.create_repo(repo_name)
-        updates = {'group': 'test_group_for_update'}
+        updates = {'repo_name': '{}/{}'.format(fake_repo_group, repo_name)}
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
-            expected = 'repository group `%s` does not exist' % (
-                updates['group'],)
+            expected = {
+                'repo_group': 'Repository group `{}` does not exist'.format(fake_repo_group)
+            }
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)

rhodecode/api/tests/test_update_repo_group.py

@@ -30,22 +30,30 b' from rhodecode.api.tests.utils import ('
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepoGroup(object):
+
     def test_update_group_name(self, user_util):
         new_group_name = 'new-group'
         initial_name = self._update(user_util, group_name=new_group_name)
         assert RepoGroupModel()._get_repo_group(initial_name) is None
-        assert RepoGroupModel()._get_repo_group(new_group_name) is not None
+        new_group = RepoGroupModel()._get_repo_group(new_group_name)
+        assert new_group is not None
+        assert new_group.full_path == new_group_name
 
-    def test_update_parent(self, user_util):
+    def test_update_group_name_change_parent(self, user_util):
+
         parent_group = user_util.create_repo_group()
-        initial_name = self._update(user_util, parent=parent_group.name)
+        parent_group_name = parent_group.name
 
-        expected_group_name = '{}/{}'.format(parent_group.name, initial_name)
+        expected_group_name = '{}/{}'.format(parent_group_name, 'new-group')
+        initial_name = self._update(user_util, group_name=expected_group_name)
+
         repo_group = RepoGroupModel()._get_repo_group(expected_group_name)
+
         assert repo_group is not None
         assert repo_group.group_name == expected_group_name
-        assert repo_group.name == initial_name
+        assert repo_group.full_path == expected_group_name
         assert RepoGroupModel()._get_repo_group(initial_name) is None
+
         new_path = os.path.join(
             RepoGroupModel().repos_path, *repo_group.full_path_splitted)
         assert os.path.exists(new_path)
@@ -67,15 +75,47 b' class TestApiUpdateRepoGroup(object):'
         repo_group = RepoGroupModel()._get_repo_group(initial_name)
         assert repo_group.user.username == owner
 
-    def test_api_update_repo_group_by_regular_user_no_permission(
-            self, backend):
-        repo = backend.create_repo()
-        repo_name = repo.repo_name
+    def test_update_group_name_conflict_with_existing(self, user_util):
+        group_1 = user_util.create_repo_group()
+        group_2 = user_util.create_repo_group()
+        repo_group_name_1 = group_1.group_name
+        repo_group_name_2 = group_2.group_name
 
         id_, params = build_data(
-            self.apikey_regular, 'update_repo_group', repogroupid=repo_name)
+            self.apikey, 'update_repo_group', repogroupid=repo_group_name_1,
+            group_name=repo_group_name_2)
+        response = api_call(self.app, params)
+        expected = {
+            'unique_repo_group_name':
+                'Repository group with name `{}` already exists'.format(
+                    repo_group_name_2)}
+        assert_error(id_, expected, given=response.body)
+
+    def test_api_update_repo_group_by_regular_user_no_permission(self, user_util):
+        temp_user = user_util.create_user()
+        temp_user_api_key = temp_user.api_key
+        parent_group = user_util.create_repo_group()
+        repo_group_name = parent_group.group_name
+        id_, params = build_data(
+            temp_user_api_key, 'update_repo_group', repogroupid=repo_group_name)
         response = api_call(self.app, params)
-        expected = 'repository group `%s` does not exist' % (repo_name,)
+        expected = 'repository group `%s` does not exist' % (repo_group_name,)
+        assert_error(id_, expected, given=response.body)
+
+    def test_api_update_repo_group_regular_user_no_root_write_permissions(
+            self, user_util):
+        temp_user = user_util.create_user()
+        temp_user_api_key = temp_user.api_key
+        parent_group = user_util.create_repo_group(owner=temp_user.username)
+        repo_group_name = parent_group.group_name
+
+        id_, params = build_data(
+            temp_user_api_key, 'update_repo_group', repogroupid=repo_group_name,
+            group_name='at-root-level')
+        response = api_call(self.app, params)
+        expected = {
+            'repo_group': 'You do not have the permission to store '
+                          'repository groups in the root location.'}
         assert_error(id_, expected, given=response.body)
 
     def _update(self, user_util, **kwargs):
@@ -89,7 +129,10 b' class TestApiUpdateRepoGroup(object):'
             self.apikey, 'update_repo_group', repogroupid=initial_name,
             **kwargs)
         response = api_call(self.app, params)
-        ret = {
+
+        repo_group = RepoGroupModel.cls.get(repo_group.group_id)
+
+        expected = {
             'msg': 'updated repository group ID:{} {}'.format(
                 repo_group.group_id, repo_group.group_name),
             'repo_group': {
@@ -103,5 +146,5 b' class TestApiUpdateRepoGroup(object):'
                     if repo_group.parent_group else None)
             }
         }
-        assert_ok(id_, ret, given=response.body)
+        assert_ok(id_, expected, given=response.body)
         return initial_name

rhodecode/api/tests/test_utils.py

@@ -249,7 +249,7 b' class TestRepoAccess(object):'
         fake_repo = Mock()
         with self.repo_perm_patch as rmock:
             rmock.return_value = repo_mock
-            assert utils.has_repo_permissions(
+            assert utils.validate_repo_permissions(
                 'fake_user', 'fake_repo_id', fake_repo,
                 ['perm1', 'perm2'])
             rmock.assert_called_once_with(*['perm1', 'perm2'])
@@ -263,6 +263,6 b' class TestRepoAccess(object):'
         with self.repo_perm_patch as rmock:
             rmock.return_value = repo_mock
             with pytest.raises(JSONRPCError) as excinfo:
-                utils.has_repo_permissions(
+                utils.validate_repo_permissions(
                     'fake_user', 'fake_repo_id', fake_repo, 'perms')
                 assert 'fake_repo_id' in excinfo

rhodecode/api/utils.py

@@ -26,7 +26,8 b' import collections'
 import logging
 
 from rhodecode.api.exc import JSONRPCError
-from rhodecode.lib.auth import HasPermissionAnyApi, HasRepoPermissionAnyApi
+from rhodecode.lib.auth import HasPermissionAnyApi, HasRepoPermissionAnyApi, \
+    HasRepoGroupPermissionAnyApi
 from rhodecode.lib.utils import safe_unicode
 from rhodecode.controllers.utils import get_commit_from_ref_name
 from rhodecode.lib.vcs.exceptions import RepositoryError
@@ -153,7 +154,7 b' def has_superadmin_permission(apiuser):'
     return False
 
 
-def has_repo_permissions(apiuser, repoid, repo, perms):
+def validate_repo_permissions(apiuser, repoid, repo, perms):
     """
     Raise JsonRPCError if apiuser is not authorized or return True
 
@@ -170,6 +171,36 b' def has_repo_permissions(apiuser, repoid'
     return True
 
 
+def validate_repo_group_permissions(apiuser, repogroupid, repo_group, perms):
+    """
+    Raise JsonRPCError if apiuser is not authorized or return True
+
+    :param apiuser:
+    :param repogroupid: just the id of repository group
+    :param repo_group: instance of repo_group
+    :param perms:
+    """
+    if not HasRepoGroupPermissionAnyApi(*perms)(
+            user=apiuser, group_name=repo_group.group_name):
+        raise JSONRPCError(
+            'repository group `%s` does not exist' % repogroupid)
+
+    return True
+
+
+def validate_set_owner_permissions(apiuser, owner):
+    if isinstance(owner, Optional):
+        owner = get_user_or_error(apiuser.user_id)
+    else:
+        if has_superadmin_permission(apiuser):
+            owner = get_user_or_error(owner)
+        else:
+            # forbid setting owner for non-admins
+            raise JSONRPCError(
+                'Only RhodeCode super-admin can specify `owner` param')
+    return owner
+
+
 def get_user_or_error(userid):
     """
     Get user by id or name or return JsonRPCError if not found

rhodecode/api/views/pull_request_api.py

@@ -25,7 +25,7 b' from rhodecode.api import jsonrpc_method'
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
     get_pull_request_or_error, get_commit_or_error, get_user_or_error,
-    has_repo_permissions, resolve_ref_or_error)
+    validate_repo_permissions, resolve_ref_or_error)
 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
 from rhodecode.lib.base import vcs_operation_context
 from rhodecode.lib.utils2 import str2bool
@@ -96,6 +96,15 b' def get_pull_request(request, apiuser, r'
                                          "commit_id": "<commit_id>",
                                      }
                                  },
+            "merge":             {
+                                     "clone_url":   "<clone_url>",
+                                     "reference":
+                                     {
+                                         "name":      "<name>",
+                                         "type":      "<type>",
+                                         "commit_id": "<commit_id>",
+                                     }
+                                 },
            "author":             <user_obj>,
            "reviewers":          [
                                      ...
@@ -178,6 +187,15 b' def get_pull_requests(request, apiuser, '
                                              "commit_id": "<commit_id>",
                                          }
                                      },
+                "merge":             {
+                                         "clone_url":   "<clone_url>",
+                                         "reference":
+                                         {
+                                             "name":      "<name>",
+                                             "type":      "<type>",
+                                             "commit_id": "<commit_id>",
+                                         }
+                                     },
                "author":             <user_obj>,
                "reviewers":          [
                                          ...
@@ -197,7 +215,7 b' def get_pull_requests(request, apiuser, '
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     status = Optional.extract(status)
     pull_requests = PullRequestModel().get_all(repo, statuses=[status])
@@ -232,7 +250,12 b' def merge_pull_request(request, apiuser,'
             "executed":         "<bool>",
             "failure_reason":   "<int>",
             "merge_commit_id":  "<merge_commit_id>",
-            "possible":         "<bool>"
+            "possible":         "<bool>",
+            "merge_ref":        {
+                                    "commit_id": "<commit_id>",
+                                    "type":      "<type>",
+                                    "name":      "<name>"
+                                }
         },
       "error": null
 
@@ -260,13 +283,21 b' def merge_pull_request(request, apiuser,'
         request.environ, repo_name=target_repo.repo_name,
         username=apiuser.username, action='push',
         scm=target_repo.repo_type)
-    data = PullRequestModel().merge(pull_request, apiuser, extras=extras)
-    if data.executed:
+    merge_response = PullRequestModel().merge(
+        pull_request, apiuser, extras=extras)
+    if merge_response.executed:
         PullRequestModel().close_pull_request(
             pull_request.pull_request_id, apiuser)
 
         Session().commit()
-    return data
+
+    # In previous versions the merge response directly contained the merge
+    # commit id. It is now contained in the merge reference object. To be
+    # backwards compatible we have to extract it again.
+    merge_response = merge_response._asdict()
+    merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
+
+    return merge_response
 
 
 @jsonrpc_method()
@@ -463,12 +494,17 b' def create_pull_request('
     :type description: Optional(str)
     :param reviewers: Set the new pull request reviewers list.
     :type reviewers: Optional(list)
+        Accepts username strings or objects of the format:
+        {
+            'username': 'nick', 'reasons': ['original author']
+        }
     """
+
     source = get_repo_or_error(source_repo)
     target = get_repo_or_error(target_repo)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, source_repo, source, _perms)
+        validate_repo_permissions(apiuser, source_repo, source, _perms)
 
     full_source_ref = resolve_ref_or_error(source_ref, source)
     full_target_ref = resolve_ref_or_error(target_ref, target)
@@ -490,12 +526,21 b' def create_pull_request('
     if not ancestor:
         raise JSONRPCError('no common ancestor found')
 
-    reviewer_names = Optional.extract(reviewers) or []
-    if not isinstance(reviewer_names, list):
+    reviewer_objects = Optional.extract(reviewers) or []
+    if not isinstance(reviewer_objects, list):
         raise JSONRPCError('reviewers should be specified as a list')
 
-    reviewer_users = [get_user_or_error(n) for n in reviewer_names]
-    reviewer_ids = [u.user_id for u in reviewer_users]
+    reviewers_reasons = []
+    for reviewer_object in reviewer_objects:
+        reviewer_reasons = []
+        if isinstance(reviewer_object, (basestring, int)):
+            reviewer_username = reviewer_object
+        else:
+            reviewer_username = reviewer_object['username']
+            reviewer_reasons = reviewer_object.get('reasons', [])
+
+        user = get_user_or_error(reviewer_username)
+        reviewers_reasons.append((user.user_id, reviewer_reasons))
 
     pull_request_model = PullRequestModel()
     pull_request = pull_request_model.create(
@@ -506,7 +551,7 b' def create_pull_request('
         target_ref=full_target_ref,
         revisions=reversed(
             [commit.raw_id for commit in reversed(commit_ranges)]),
-        reviewers=reviewer_ids,
+        reviewers=reviewers_reasons,
         title=title,
         description=Optional.extract(description)
     )
@@ -585,12 +630,23 b' def update_pull_request('
             'pull request `%s` update failed, pull request is closed' % (
                 pullrequestid,))
 
-    reviewer_names = Optional.extract(reviewers) or []
-    if not isinstance(reviewer_names, list):
+    reviewer_objects = Optional.extract(reviewers) or []
+    if not isinstance(reviewer_objects, list):
         raise JSONRPCError('reviewers should be specified as a list')
 
-    reviewer_users = [get_user_or_error(n) for n in reviewer_names]
-    reviewer_ids = [u.user_id for u in reviewer_users]
+    reviewers_reasons = []
+    reviewer_ids = set()
+    for reviewer_object in reviewer_objects:
+        reviewer_reasons = []
+        if isinstance(reviewer_object, (int, basestring)):
+            reviewer_username = reviewer_object
+        else:
+            reviewer_username = reviewer_object['username']
+            reviewer_reasons = reviewer_object.get('reasons', [])
+
+        user = get_user_or_error(reviewer_username)
+        reviewer_ids.add(user.user_id)
+        reviewers_reasons.append((user.user_id, reviewer_reasons))
 
     title = Optional.extract(title)
     description = Optional.extract(description)
@@ -603,15 +659,15 b' def update_pull_request('
     commit_changes = {"added": [], "common": [], "removed": []}
     if str2bool(Optional.extract(update_commits)):
         if PullRequestModel().has_valid_update_type(pull_request):
-            _version, _commit_changes = PullRequestModel().update_commits(
+            update_response = PullRequestModel().update_commits(
                 pull_request)
-            commit_changes = _commit_changes or commit_changes
+            commit_changes = update_response.changes or commit_changes
         Session().commit()
 
     reviewers_changes = {"added": [], "removed": []}
     if reviewer_ids:
         added_reviewers, removed_reviewers = \
-            PullRequestModel().update_reviewers(pull_request, reviewer_ids)
+            PullRequestModel().update_reviewers(pull_request, reviewers_reasons)
 
         reviewers_changes['added'] = sorted(
             [get_user_or_error(n).username for n in added_reviewers])
@@ -631,5 +687,5 b' def update_pull_request('
         'updated_commits': commit_changes,
         'updated_reviewers': reviewers_changes
     }
+
     return data
-

rhodecode/api/views/repo_api.py

@@ -21,29 +21,26 b''
 import logging
 import time
 
-import colander
-
-from rhodecode import BACKENDS
-from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCForbidden, json
+import rhodecode
+from rhodecode.api import (
+    jsonrpc_method, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
-    get_user_group_or_error, get_user_or_error, has_repo_permissions,
-    get_perm_or_error, store_update, get_repo_group_or_error, parse_args,
-    get_origin, build_commit_data)
-from rhodecode.lib.auth import (
-    HasPermissionAnyApi, HasRepoGroupPermissionAnyApi,
-    HasUserGroupPermissionAnyApi)
+    get_user_group_or_error, get_user_or_error, validate_repo_permissions,
+    get_perm_or_error, parse_args, get_origin, build_commit_data,
+    validate_set_owner_permissions)
+from rhodecode.lib.auth import HasPermissionAnyApi, HasUserGroupPermissionAnyApi
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
-from rhodecode.lib.utils import map_groups
 from rhodecode.lib.utils2 import str2bool, time_to_datetime
+from rhodecode.lib.ext_json import json
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.db import (
     Session, ChangesetStatus, RepositoryField, Repository)
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import ScmModel, RepoList
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
+from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import repo_schema
 
 log = logging.getLogger(__name__)
@@ -177,6 +174,7 b' def get_repo(request, apiuser, repoid, c'
 
     repo = get_repo_or_error(repoid)
     cache = Optional.extract(cache)
+
     include_secrets = False
     if has_superadmin_permission(apiuser):
         include_secrets = True
@@ -184,7 +182,7 b' def get_repo(request, apiuser, repoid, c'
         # check if we have at least read permission for this repo !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     permissions = []
     for _user in repo.permissions():
@@ -292,7 +290,7 b' def get_repo_changeset(request, apiuser,'
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
@@ -355,7 +353,7 b' def get_repo_changesets(request, apiuser'
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
@@ -450,7 +448,7 b' def get_repo_nodes(request, apiuser, rep'
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     ret_type = Optional.extract(ret_type)
     details = Optional.extract(details)
@@ -523,7 +521,7 b' def get_repo_refs(request, apiuser, repo'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         # check if repo is not empty by any chance, skip quicker if it is.
@@ -538,26 +536,30 b' def get_repo_refs(request, apiuser, repo'
 
 
 @jsonrpc_method()
-def create_repo(request, apiuser, repo_name, repo_type,
-                owner=Optional(OAttr('apiuser')), description=Optional(''),
-                private=Optional(False), clone_uri=Optional(None),
-                landing_rev=Optional('rev:tip'),
-                enable_statistics=Optional(False),
-                enable_locking=Optional(False),
-                enable_downloads=Optional(False),
-                copy_permissions=Optional(False)):
+def create_repo(
+        request, apiuser, repo_name, repo_type,
+        owner=Optional(OAttr('apiuser')),
+        description=Optional(''),
+        private=Optional(False),
+        clone_uri=Optional(None),
+        landing_rev=Optional('rev:tip'),
+        enable_statistics=Optional(False),
+        enable_locking=Optional(False),
+        enable_downloads=Optional(False),
+        copy_permissions=Optional(False)):
     """
     Creates a repository.
 
-    * If the repository name contains "/", all the required repository
-      groups will be created.
+    * If the repository name contains "/", repository will be created inside
+      a repository group or nested repository groups
 
-      For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-      (with "foo" as parent). It will also create the "baz" repository
-      with "bar" as |repo| group.
+      For example "foo/bar/repo1" will create |repo| called "repo1" inside
+      group "foo/bar". You have to have permissions to access and write to
+      the last repository group ("bar" in this example)
 
     This command can only be run using an |authtoken| with at least
-    write permissions to the |repo|.
+    permissions to create repositories, or write permissions to
+    parent repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
@@ -569,9 +571,9 b' def create_repo(request, apiuser, repo_n'
     :type owner: Optional(str)
     :param description: Set the repository description.
     :type description: Optional(str)
-    :param private:
+    :param private: set repository as private
     :type private: bool
-    :param clone_uri:
+    :param clone_uri: set clone_uri
     :type clone_uri: str
     :param landing_rev: <rev_type>:<rev>
     :type landing_rev: str
@@ -606,53 +608,17 b' def create_repo(request, apiuser, repo_n'
       id : <id_given_in_input>
       result : null
       error :  {
-         'failed to create repository `<repo_name>`
+         'failed to create repository `<repo_name>`'
       }
 
     """
-    schema = repo_schema.RepoSchema()
-    try:
-        data = schema.deserialize({
-            'repo_name': repo_name
-        })
-    except colander.Invalid as e:
-        raise JSONRPCError("Validation failed: %s" % (e.asdict(),))
-    repo_name = data['repo_name']
 
-    (repo_name_cleaned,
-     parent_group_name) = RepoGroupModel()._get_group_name_and_parent(
-        repo_name)
-
-    if not HasPermissionAnyApi(
-            'hg.admin', 'hg.create.repository')(user=apiuser):
-        # check if we have admin permission for this repo group if given !
-
-        if parent_group_name:
-            repogroupid = parent_group_name
-            repo_group = get_repo_group_or_error(parent_group_name)
+    owner = validate_set_owner_permissions(apiuser, owner)
 
-            _perms = ('group.admin',)
-            if not HasRepoGroupPermissionAnyApi(*_perms)(
-                    user=apiuser, group_name=repo_group.group_name):
-                raise JSONRPCError(
-                    'repository group `%s` does not exist' % (
-                        repogroupid,))
-        else:
-            raise JSONRPCForbidden()
-
-    if not has_superadmin_permission(apiuser):
-        if not isinstance(owner, Optional):
-            # forbid setting owner for non-admins
-            raise JSONRPCError(
-                'Only RhodeCode admin can specify `owner` param')
-
-    if isinstance(owner, Optional):
-        owner = apiuser.user_id
-
-    owner = get_user_or_error(owner)
-
-    if RepoModel().get_by_repo_name(repo_name):
-        raise JSONRPCError("repo `%s` already exist" % repo_name)
+    description = Optional.extract(description)
+    copy_permissions = Optional.extract(copy_permissions)
+    clone_uri = Optional.extract(clone_uri)
+    landing_commit_ref = Optional.extract(landing_rev)
 
     defs = SettingsModel().get_default_repo_settings(strip_prefix=True)
     if isinstance(private, Optional):
@@ -666,32 +632,44 b' def create_repo(request, apiuser, repo_n'
     if isinstance(enable_downloads, Optional):
         enable_downloads = defs.get('repo_enable_downloads')
 
-    clone_uri = Optional.extract(clone_uri)
-    description = Optional.extract(description)
-    landing_rev = Optional.extract(landing_rev)
-    copy_permissions = Optional.extract(copy_permissions)
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        # user caller
+        user=apiuser)
 
     try:
-        # create structure of groups and return the last group
-        repo_group = map_groups(repo_name)
+        schema_data = schema.deserialize(dict(
+            repo_name=repo_name,
+            repo_type=repo_type,
+            repo_owner=owner.username,
+            repo_description=description,
+            repo_landing_commit_ref=landing_commit_ref,
+            repo_clone_uri=clone_uri,
+            repo_private=private,
+            repo_copy_permissions=copy_permissions,
+            repo_enable_statistics=enable_statistics,
+            repo_enable_downloads=enable_downloads,
+            repo_enable_locking=enable_locking))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    try:
         data = {
-            'repo_name': repo_name_cleaned,
-            'repo_name_full': repo_name,
-            'repo_type': repo_type,
-            'repo_description': description,
             'owner': owner,
-            'repo_private': private,
-            'clone_uri': clone_uri,
-            'repo_group': repo_group.group_id if repo_group else None,
-            'repo_landing_rev': landing_rev,
-            'enable_statistics': enable_statistics,
-            'enable_locking': enable_locking,
-            'enable_downloads': enable_downloads,
-            'repo_copy_permissions': copy_permissions,
+            'repo_name': schema_data['repo_group']['repo_name_without_group'],
+            'repo_name_full': schema_data['repo_name'],
+            'repo_group': schema_data['repo_group']['repo_group_id'],
+            'repo_type': schema_data['repo_type'],
+            'repo_description': schema_data['repo_description'],
+            'repo_private': schema_data['repo_private'],
+            'clone_uri': schema_data['repo_clone_uri'],
+            'repo_landing_rev': schema_data['repo_landing_commit_ref'],
+            'enable_statistics': schema_data['repo_enable_statistics'],
+            'enable_locking': schema_data['repo_enable_locking'],
+            'enable_downloads': schema_data['repo_enable_downloads'],
+            'repo_copy_permissions': schema_data['repo_copy_permissions'],
         }
 
-        if repo_type not in BACKENDS.keys():
-            raise Exception("Invalid backend type %s" % repo_type)
         task = RepoModel().create(form_data=data, cur_user=owner)
         from celery.result import BaseAsyncResult
         task_id = None
@@ -699,17 +677,17 b' def create_repo(request, apiuser, repo_n'
             task_id = task.task_id
         # no commit, it's done in RepoModel, or async via celery
         return {
-            'msg': "Created new repository `%s`" % (repo_name,),
+            'msg': "Created new repository `%s`" % (schema_data['repo_name'],),
             'success': True,  # cannot return the repo data here since fork
-            # cann be done async
+            # can be done async
             'task': task_id
         }
     except Exception:
         log.exception(
             u"Exception while trying to create the repository %s",
-            repo_name)
+            schema_data['repo_name'])
         raise JSONRPCError(
-            'failed to create repository `%s`' % (repo_name,))
+            'failed to create repository `%s`' % (schema_data['repo_name'],))
 
 
 @jsonrpc_method()
@@ -735,7 +713,7 b' def add_field_to_repo(request, apiuser, '
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     label = Optional.extract(label) or key
     description = Optional.extract(description)
@@ -778,7 +756,7 b' def remove_field_from_repo(request, apiu'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     field = RepositoryField.get_by_key_name(key, repo)
     if not field:
@@ -800,33 +778,38 b' def remove_field_from_repo(request, apiu'
 
 
 @jsonrpc_method()
-def update_repo(request, apiuser, repoid, name=Optional(None),
-                owner=Optional(OAttr('apiuser')),
-                group=Optional(None),
-                fork_of=Optional(None),
-                description=Optional(''), private=Optional(False),
-                clone_uri=Optional(None), landing_rev=Optional('rev:tip'),
-                enable_statistics=Optional(False),
-                enable_locking=Optional(False),
-                enable_downloads=Optional(False),
-                fields=Optional('')):
+def update_repo(
+        request, apiuser, repoid, repo_name=Optional(None),
+        owner=Optional(OAttr('apiuser')), description=Optional(''),
+        private=Optional(False), clone_uri=Optional(None),
+        landing_rev=Optional('rev:tip'), fork_of=Optional(None),
+        enable_statistics=Optional(False),
+        enable_locking=Optional(False),
+        enable_downloads=Optional(False), fields=Optional('')):
     """
     Updates a repository with the given information.
 
     This command can only be run using an |authtoken| with at least
-    write permissions to the |repo|.
+    admin permissions to the |repo|.
+
+    * If the repository name contains "/", repository will be updated
+      accordingly with a repository group or nested repository groups
+
+      For example repoid=repo-test name="foo/bar/repo-test" will update |repo|
+      called "repo-test" and place it inside group "foo/bar".
+      You have to have permissions to access and write to the last repository
+      group ("bar" in this example)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: repository name or repository ID.
     :type repoid: str or int
-    :param name: Update the |repo| name.
-    :type name: str
+    :param repo_name: Update the |repo| name, including the
+        repository group it's in.
+    :type repo_name: str
     :param owner: Set the |repo| owner.
     :type owner: str
-    :param group: Set the |repo| group the |repo| belongs to.
-    :type group: str
-    :param fork_of: Set the master |repo| name.
+    :param fork_of: Set the |repo| as fork of another |repo|.
     :type fork_of: str
     :param description: Update the |repo| description.
     :type description: str
@@ -834,69 +817,115 b' def update_repo(request, apiuser, repoid'
     :type private: bool
     :param clone_uri: Update the |repo| clone URI.
     :type clone_uri: str
-    :param landing_rev: Set the |repo| landing revision. Default is
-        ``tip``.
+    :param landing_rev: Set the |repo| landing revision. Default is ``rev:tip``.
     :type landing_rev: str
-    :param enable_statistics: Enable statistics on the |repo|,
-        (True | False).
+    :param enable_statistics: Enable statistics on the |repo|, (True | False).
     :type enable_statistics: bool
     :param enable_locking: Enable |repo| locking.
     :type enable_locking: bool
-    :param enable_downloads: Enable downloads from the |repo|,
-        (True | False).
+    :param enable_downloads: Enable downloads from the |repo|, (True | False).
     :type enable_downloads: bool
     :param fields: Add extra fields to the |repo|. Use the following
         example format: ``field_key=field_val,field_key2=fieldval2``.
         Escape ', ' with \,
     :type fields: str
     """
+
     repo = get_repo_or_error(repoid)
+
     include_secrets = False
-    if has_superadmin_permission(apiuser):
+    if not has_superadmin_permission(apiuser):
+        validate_repo_permissions(apiuser, repoid, repo, ('repository.admin',))
+    else:
         include_secrets = True
-    else:
-        _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+
+    updates = dict(
+        repo_name=repo_name
+        if not isinstance(repo_name, Optional) else repo.repo_name,
+
+        fork_id=fork_of
+        if not isinstance(fork_of, Optional) else repo.fork.repo_name if repo.fork else None,
+
+        user=owner
+        if not isinstance(owner, Optional) else repo.user.username,
+
+        repo_description=description
+        if not isinstance(description, Optional) else repo.description,
+
+        repo_private=private
+        if not isinstance(private, Optional) else repo.private,
+
+        clone_uri=clone_uri
+        if not isinstance(clone_uri, Optional) else repo.clone_uri,
+
+        repo_landing_rev=landing_rev
+        if not isinstance(landing_rev, Optional) else repo._landing_revision,
+
+        repo_enable_statistics=enable_statistics
+        if not isinstance(enable_statistics, Optional) else repo.enable_statistics,
+
+        repo_enable_locking=enable_locking
+        if not isinstance(enable_locking, Optional) else repo.enable_locking,
+
+        repo_enable_downloads=enable_downloads
+        if not isinstance(enable_downloads, Optional) else repo.enable_downloads)
+
+    ref_choices, _labels = ScmModel().get_repo_landing_revs(repo=repo)
 
-    updates = {
-        # update function requires this.
-        'repo_name': repo.just_name
-    }
-    repo_group = group
-    if not isinstance(repo_group, Optional):
-        repo_group = get_repo_group_or_error(repo_group)
-        repo_group = repo_group.group_id
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        repo_ref_options=ref_choices,
+        # user caller
+        user=apiuser,
+        old_values=repo.get_api_data())
+    try:
+        schema_data = schema.deserialize(dict(
+            # we save old value, users cannot change type
+            repo_type=repo.repo_type,
+
+            repo_name=updates['repo_name'],
+            repo_owner=updates['user'],
+            repo_description=updates['repo_description'],
+            repo_clone_uri=updates['clone_uri'],
+            repo_fork_of=updates['fork_id'],
+            repo_private=updates['repo_private'],
+            repo_landing_commit_ref=updates['repo_landing_rev'],
+            repo_enable_statistics=updates['repo_enable_statistics'],
+            repo_enable_downloads=updates['repo_enable_downloads'],
+            repo_enable_locking=updates['repo_enable_locking']))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
 
-    repo_fork_of = fork_of
-    if not isinstance(repo_fork_of, Optional):
-        repo_fork_of = get_repo_or_error(repo_fork_of)
-        repo_fork_of = repo_fork_of.repo_id
+    # save validated data back into the updates dict
+    validated_updates = dict(
+        repo_name=schema_data['repo_group']['repo_name_without_group'],
+        repo_group=schema_data['repo_group']['repo_group_id'],
+
+        user=schema_data['repo_owner'],
+        repo_description=schema_data['repo_description'],
+        repo_private=schema_data['repo_private'],
+        clone_uri=schema_data['repo_clone_uri'],
+        repo_landing_rev=schema_data['repo_landing_commit_ref'],
+        repo_enable_statistics=schema_data['repo_enable_statistics'],
+        repo_enable_locking=schema_data['repo_enable_locking'],
+        repo_enable_downloads=schema_data['repo_enable_downloads'],
+    )
+
+    if schema_data['repo_fork_of']:
+        fork_repo = get_repo_or_error(schema_data['repo_fork_of'])
+        validated_updates['fork_id'] = fork_repo.repo_id
+
+    # extra fields
+    fields = parse_args(Optional.extract(fields), key_prefix='ex_')
+    if fields:
+        validated_updates.update(fields)
 
     try:
-        store_update(updates, name, 'repo_name')
-        store_update(updates, repo_group, 'repo_group')
-        store_update(updates, repo_fork_of, 'fork_id')
-        store_update(updates, owner, 'user')
-        store_update(updates, description, 'repo_description')
-        store_update(updates, private, 'repo_private')
-        store_update(updates, clone_uri, 'clone_uri')
-        store_update(updates, landing_rev, 'repo_landing_rev')
-        store_update(updates, enable_statistics, 'repo_enable_statistics')
-        store_update(updates, enable_locking, 'repo_enable_locking')
-        store_update(updates, enable_downloads, 'repo_enable_downloads')
-
-        # extra fields
-        fields = parse_args(Optional.extract(fields), key_prefix='ex_')
-        if fields:
-            updates.update(fields)
-
-        RepoModel().update(repo, **updates)
+        RepoModel().update(repo, **validated_updates)
         Session().commit()
         return {
-            'msg': 'updated repo ID:%s %s' % (
-                repo.repo_id, repo.repo_name),
-            'repository': repo.get_api_data(
-                include_secrets=include_secrets)
+            'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
+            'repository': repo.get_api_data(include_secrets=include_secrets)
         }
     except Exception:
         log.exception(
@@ -908,26 +937,33 b' def update_repo(request, apiuser, repoid'
 @jsonrpc_method()
 def fork_repo(request, apiuser, repoid, fork_name,
               owner=Optional(OAttr('apiuser')),
-              description=Optional(''), copy_permissions=Optional(False),
-              private=Optional(False), landing_rev=Optional('rev:tip')):
+              description=Optional(''),
+              private=Optional(False),
+              clone_uri=Optional(None),
+              landing_rev=Optional('rev:tip'),
+              copy_permissions=Optional(False)):
     """
     Creates a fork of the specified |repo|.
 
-    * If using |RCE| with Celery this will immediately return a success
-      message, even though the fork will be created asynchronously.
+    * If the fork_name contains "/", fork will be created inside
+      a repository group or nested repository groups
 
-    This command can only be run using an |authtoken| with fork
-    permissions on the |repo|.
+      For example "foo/bar/fork-repo" will create fork called "fork-repo"
+      inside group "foo/bar". You have to have permissions to access and
+      write to the last repository group ("bar" in this example)
+
+    This command can only be run using an |authtoken| with minimum
+    read permissions of the forked repo, create fork permissions for an user.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set repository name or repository ID.
     :type repoid: str or int
-    :param fork_name: Set the fork name.
+    :param fork_name: Set the fork name, including it's repository group membership.
     :type fork_name: str
     :param owner: Set the fork owner.
     :type owner: str
-    :param description: Set the fork descripton.
+    :param description: Set the fork description.
     :type description: str
     :param copy_permissions: Copy permissions from parent |repo|. The
         default is False.
@@ -965,71 +1001,63 b' def fork_repo(request, apiuser, repoid, '
         error:  null
 
     """
-    if not has_superadmin_permission(apiuser):
-        if not HasPermissionAnyApi('hg.fork.repository')(user=apiuser):
-            raise JSONRPCForbidden()
 
     repo = get_repo_or_error(repoid)
     repo_name = repo.repo_name
 
-    (fork_name_cleaned,
-     parent_group_name) = RepoGroupModel()._get_group_name_and_parent(
-        fork_name)
-
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for
         # this repo that we fork !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read')
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
-        if not isinstance(owner, Optional):
-            # forbid setting owner for non super admins
-            raise JSONRPCError(
-                'Only RhodeCode admin can specify `owner` param'
-            )
-        # check if we have a create.repo permission if not maybe the parent
-        # group permission
-        if not HasPermissionAnyApi('hg.create.repository')(user=apiuser):
-            if parent_group_name:
-                repogroupid = parent_group_name
-                repo_group = get_repo_group_or_error(parent_group_name)
+        # check if the regular user has at least fork permissions as well
+        if not HasPermissionAnyApi('hg.fork.repository')(user=apiuser):
+            raise JSONRPCForbidden()
+
+    # check if user can set owner parameter
+    owner = validate_set_owner_permissions(apiuser, owner)
 
-                _perms = ('group.admin',)
-                if not HasRepoGroupPermissionAnyApi(*_perms)(
-                        user=apiuser, group_name=repo_group.group_name):
-                    raise JSONRPCError(
-                        'repository group `%s` does not exist' % (
-                            repogroupid,))
-            else:
-                raise JSONRPCForbidden()
+    description = Optional.extract(description)
+    copy_permissions = Optional.extract(copy_permissions)
+    clone_uri = Optional.extract(clone_uri)
+    landing_commit_ref = Optional.extract(landing_rev)
+    private = Optional.extract(private)
 
-    _repo = RepoModel().get_by_repo_name(fork_name)
-    if _repo:
-        type_ = 'fork' if _repo.fork else 'repo'
-        raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))
-
-    if isinstance(owner, Optional):
-        owner = apiuser.user_id
-
-    owner = get_user_or_error(owner)
+    schema = repo_schema.RepoSchema().bind(
+        repo_type_options=rhodecode.BACKENDS.keys(),
+        # user caller
+        user=apiuser)
 
     try:
-        # create structure of groups and return the last group
-        repo_group = map_groups(fork_name)
-        form_data = {
-            'repo_name': fork_name_cleaned,
-            'repo_name_full': fork_name,
-            'repo_group': repo_group.group_id if repo_group else None,
-            'repo_type': repo.repo_type,
-            'description': Optional.extract(description),
-            'private': Optional.extract(private),
-            'copy_permissions': Optional.extract(copy_permissions),
-            'landing_rev': Optional.extract(landing_rev),
+        schema_data = schema.deserialize(dict(
+            repo_name=fork_name,
+            repo_type=repo.repo_type,
+            repo_owner=owner.username,
+            repo_description=description,
+            repo_landing_commit_ref=landing_commit_ref,
+            repo_clone_uri=clone_uri,
+            repo_private=private,
+            repo_copy_permissions=copy_permissions))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    try:
+        data = {
             'fork_parent_id': repo.repo_id,
+
+            'repo_name': schema_data['repo_group']['repo_name_without_group'],
+            'repo_name_full': schema_data['repo_name'],
+            'repo_group': schema_data['repo_group']['repo_group_id'],
+            'repo_type': schema_data['repo_type'],
+            'description': schema_data['repo_description'],
+            'private': schema_data['repo_private'],
+            'copy_permissions': schema_data['repo_copy_permissions'],
+            'landing_rev': schema_data['repo_landing_commit_ref'],
         }
 
-        task = RepoModel().create_fork(form_data, cur_user=owner)
+        task = RepoModel().create_fork(data, cur_user=owner)
         # no commit, it's done in RepoModel, or async via celery
         from celery.result import BaseAsyncResult
         task_id = None
@@ -1037,16 +1065,18 b' def fork_repo(request, apiuser, repoid, '
             task_id = task.task_id
         return {
             'msg': 'Created fork of `%s` as `%s`' % (
-                repo.repo_name, fork_name),
+                repo.repo_name, schema_data['repo_name']),
             'success': True,  # cannot return the repo data here since fork
             # can be done async
             'task': task_id
         }
     except Exception:
-        log.exception("Exception occurred while trying to fork a repo")
+        log.exception(
+            u"Exception while trying to create fork %s",
+            schema_data['repo_name'])
         raise JSONRPCError(
             'failed to fork repository `%s` as `%s`' % (
-                repo_name, fork_name))
+                repo_name, schema_data['repo_name']))
 
 
 @jsonrpc_method()
@@ -1082,7 +1112,7 b' def delete_repo(request, apiuser, repoid'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         handle_forks = Optional.extract(forks)
@@ -1157,7 +1187,7 b' def invalidate_cache(request, apiuser, r'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     delete = Optional.extract(delete_keys)
     try:
@@ -1228,7 +1258,7 b' def lock(request, apiuser, repoid, locke'
       id : <id_given_in_input>
       result : null
       error :  {
-        'Error occurred locking repository `<reponame>`
+        'Error occurred locking repository `<reponame>`'
       }
     """
 
@@ -1236,7 +1266,7 b' def lock(request, apiuser, repoid, locke'
     if not has_superadmin_permission(apiuser):
         # check if we have at least write permission for this repo !
         _perms = ('repository.admin', 'repository.write',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
         # make sure normal user does not pass someone else userid,
         # he is not allowed to do that
@@ -1347,7 +1377,7 b' def comment_commit('
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.read', 'repository.write', 'repository.admin')
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     if isinstance(userid, Optional):
         userid = apiuser.user_id
@@ -1438,7 +1468,7 b' def grant_user_permission(request, apius'
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
 
@@ -1492,7 +1522,7 b' def revoke_user_permission(request, apiu'
     user = get_user_or_error(userid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         RepoModel().revoke_user_permission(repo=repo, user=user)
@@ -1560,7 +1590,7 b' def grant_user_group_permission(request,'
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
@@ -1625,7 +1655,7 b' def revoke_user_group_permission(request'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
@@ -1701,7 +1731,7 b' def pull(request, apiuser, repoid):'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().pull_changes(repo.repo_name, apiuser.username)
@@ -1764,7 +1794,7 b' def strip(request, apiuser, repoid, revi'
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
-        has_repo_permissions(apiuser, repoid, repo, _perms)
+        validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().strip(repo, revision, branch)

rhodecode/api/views/repo_group_api.py

@@ -21,19 +21,18 b''
 
 import logging
 
-import colander
-
-from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCForbidden
+from rhodecode.api import JSONRPCValidationError
+from rhodecode.api import jsonrpc_method, JSONRPCError
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_user_or_error,
-    store_update, get_repo_group_or_error,
-    get_perm_or_error, get_user_group_or_error, get_origin)
+    get_repo_group_or_error, get_perm_or_error, get_user_group_or_error,
+    get_origin, validate_repo_group_permissions, validate_set_owner_permissions)
 from rhodecode.lib.auth import (
-    HasPermissionAnyApi, HasRepoGroupPermissionAnyApi,
-    HasUserGroupPermissionAnyApi)
-from rhodecode.model.db import Session, RepoGroup
+    HasRepoGroupPermissionAnyApi, HasUserGroupPermissionAnyApi)
+from rhodecode.model.db import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import RepoGroupList
+from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import repo_group_schema
 
 
@@ -142,21 +141,24 b' def get_repo_groups(request, apiuser):'
 
 
 @jsonrpc_method()
-def create_repo_group(request, apiuser, group_name, description=Optional(''),
-                      owner=Optional(OAttr('apiuser')),
-                      copy_permissions=Optional(False)):
+def create_repo_group(
+        request, apiuser, group_name,
+        owner=Optional(OAttr('apiuser')),
+        description=Optional(''),
+        copy_permissions=Optional(False)):
     """
     Creates a repository group.
 
-    * If the repository group name contains "/", all the required repository
-      groups will be created.
+    * If the repository group name contains "/", repository group will be
+      created inside a repository group or nested repository groups
 
-      For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-      (with "foo" as parent). It will also create the "baz" repository
-      with "bar" as |repo| group.
+      For example "foo/bar/group1" will create repository group called "group1"
+      inside group "foo/bar". You have to have permissions to access and
+      write to the last repository group ("bar" in this example)
 
-    This command can only be run using an |authtoken| with admin
-    permissions.
+    This command can only be run using an |authtoken| with at least
+    permissions to create repository groups, or admin permissions to
+    parent repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
@@ -193,72 +195,64 b' def create_repo_group(request, apiuser, '
 
     """
 
-    schema = repo_group_schema.RepoGroupSchema()
-    try:
-        data = schema.deserialize({
-            'group_name': group_name
-        })
-    except colander.Invalid as e:
-        raise JSONRPCError("Validation failed: %s" % (e.asdict(),))
-    group_name = data['group_name']
+    owner = validate_set_owner_permissions(apiuser, owner)
 
-    if isinstance(owner, Optional):
-        owner = apiuser.user_id
-
-    group_description = Optional.extract(description)
+    description = Optional.extract(description)
     copy_permissions = Optional.extract(copy_permissions)
 
-    # get by full name with parents, check if it already exist
-    if RepoGroup.get_by_group_name(group_name):
-        raise JSONRPCError("repo group `%s` already exist" % (group_name,))
-
-    (group_name_cleaned,
-     parent_group_name) = RepoGroupModel()._get_group_name_and_parent(
-        group_name)
+    schema = repo_group_schema.RepoGroupSchema().bind(
+        # user caller
+        user=apiuser)
 
-    parent_group = None
-    if parent_group_name:
-        parent_group = get_repo_group_or_error(parent_group_name)
+    try:
+        schema_data = schema.deserialize(dict(
+            repo_group_name=group_name,
+            repo_group_owner=owner.username,
+            repo_group_description=description,
+            repo_group_copy_permissions=copy_permissions,
+        ))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
 
-    if not HasPermissionAnyApi(
-            'hg.admin', 'hg.repogroup.create.true')(user=apiuser):
-        # check if we have admin permission for this parent repo group !
-        # users without admin or hg.repogroup.create can only create other
-        # groups in groups they own so this is a required, but can be empty
-        parent_group = getattr(parent_group, 'group_name', '')
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=parent_group):
-            raise JSONRPCForbidden()
+    validated_group_name = schema_data['repo_group_name']
 
     try:
         repo_group = RepoGroupModel().create(
-            group_name=group_name,
-            group_description=group_description,
             owner=owner,
-            copy_permissions=copy_permissions)
+            group_name=validated_group_name,
+            group_description=schema_data['repo_group_name'],
+            copy_permissions=schema_data['repo_group_copy_permissions'])
         Session().commit()
         return {
-            'msg': 'Created new repo group `%s`' % group_name,
+            'msg': 'Created new repo group `%s`' % validated_group_name,
             'repo_group': repo_group.get_api_data()
         }
     except Exception:
         log.exception("Exception occurred while trying create repo group")
         raise JSONRPCError(
-            'failed to create repo group `%s`' % (group_name,))
+            'failed to create repo group `%s`' % (validated_group_name,))
 
 
 @jsonrpc_method()
 def update_repo_group(
         request, apiuser, repogroupid, group_name=Optional(''),
         description=Optional(''), owner=Optional(OAttr('apiuser')),
-        parent=Optional(None), enable_locking=Optional(False)):
+        enable_locking=Optional(False)):
     """
     Updates repository group with the details given.
 
     This command can only be run using an |authtoken| with admin
     permissions.
 
+    * If the group_name name contains "/", repository group will be updated
+      accordingly with a repository group or nested repository groups
+
+      For example repogroupid=group-test group_name="foo/bar/group-test"
+      will update repository group called "group-test" and place it
+      inside group "foo/bar".
+      You have to have permissions to access and write to the last repository
+      group ("bar" in this example)
+
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the ID of repository group.
@@ -269,29 +263,55 b' def update_repo_group('
     :type description: str
     :param owner: Set the |repo| group owner.
     :type owner: str
-    :param parent: Set the |repo| group parent.
-    :type parent: str or int
     :param enable_locking: Enable |repo| locking. The default is false.
     :type enable_locking: bool
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
+
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
+
+    updates = dict(
+        group_name=group_name
+        if not isinstance(group_name, Optional) else repo_group.group_name,
+
+        group_description=description
+        if not isinstance(description, Optional) else repo_group.group_description,
+
+        user=owner
+        if not isinstance(owner, Optional) else repo_group.user.username,
+
+        enable_locking=enable_locking
+        if not isinstance(enable_locking, Optional) else repo_group.enable_locking
+    )
 
-    updates = {}
+    schema = repo_group_schema.RepoGroupSchema().bind(
+        # user caller
+        user=apiuser,
+        old_values=repo_group.get_api_data())
+
     try:
-        store_update(updates, group_name, 'group_name')
-        store_update(updates, description, 'group_description')
-        store_update(updates, owner, 'user')
-        store_update(updates, parent, 'group_parent_id')
-        store_update(updates, enable_locking, 'enable_locking')
-        repo_group = RepoGroupModel().update(repo_group, updates)
+        schema_data = schema.deserialize(dict(
+            repo_group_name=updates['group_name'],
+            repo_group_owner=updates['user'],
+            repo_group_description=updates['group_description'],
+            repo_group_enable_locking=updates['enable_locking'],
+        ))
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
+
+    validated_updates = dict(
+        group_name=schema_data['repo_group']['repo_group_name_without_group'],
+        group_parent_id=schema_data['repo_group']['repo_group_id'],
+        user=schema_data['repo_group_owner'],
+        group_description=schema_data['repo_group_description'],
+        enable_locking=schema_data['repo_group_enable_locking'],
+    )
+
+    try:
+        RepoGroupModel().update(repo_group, validated_updates)
         Session().commit()
         return {
             'msg': 'updated repository group ID:%s %s' % (
@@ -299,7 +319,9 b' def update_repo_group('
             'repo_group': repo_group.get_api_data()
         }
     except Exception:
-        log.exception("Exception occurred while trying update repo group")
+        log.exception(
+            u"Exception occurred while trying update repo group %s",
+            repogroupid)
         raise JSONRPCError('failed to update repository group `%s`'
                            % (repogroupid,))
 
@@ -321,7 +343,7 b' def delete_repo_group(request, apiuser, '
 
       id : <id_given_in_input>
       result : {
-        'msg': 'deleted repo group ID:<repogroupid> <repogroupname>
+        'msg': 'deleted repo group ID:<repogroupid> <repogroupname>'
         'repo_group': null
       }
       error :  null
@@ -340,12 +362,9 b' def delete_repo_group(request, apiuser, '
 
     repo_group = get_repo_group_or_error(repogroupid)
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
+
     try:
         RepoGroupModel().delete(repo_group)
         Session().commit()
@@ -408,12 +427,8 b' def grant_user_permission_to_repo_group('
     repo_group = get_repo_group_or_error(repogroupid)
 
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
 
     user = get_user_or_error(userid)
     perm = get_perm_or_error(perm, prefix='group.')
@@ -487,12 +502,8 b' def revoke_user_permission_from_repo_gro'
     repo_group = get_repo_group_or_error(repogroupid)
 
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
 
     user = get_user_or_error(userid)
     apply_to_children = Optional.extract(apply_to_children)
@@ -569,12 +580,8 b' def grant_user_group_permission_to_repo_'
     perm = get_perm_or_error(perm, prefix='group.')
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
 
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
@@ -656,12 +663,8 b' def revoke_user_group_permission_from_re'
     repo_group = get_repo_group_or_error(repogroupid)
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
-        # check if we have admin permission for this repo group !
-        _perms = ('group.admin',)
-        if not HasRepoGroupPermissionAnyApi(*_perms)(
-                user=apiuser, group_name=repo_group.group_name):
-            raise JSONRPCError(
-                'repository group `%s` does not exist' % (repogroupid,))
+        validate_repo_group_permissions(
+            apiuser, repogroupid, repo_group, ('group.admin',))
 
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)

rhodecode/api/views/server_api.py

@@ -60,7 +60,13 b' def get_server_info(request, apiuser):'
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
-    return ScmModel().get_server_info(request.environ)
+    server_info = ScmModel().get_server_info(request.environ)
+    # rhodecode-index requires those
+
+    server_info['index_storage'] = server_info['search']['value']['location']
+    server_info['storage'] = server_info['storage']['value']['path']
+
+    return server_info
 
 
 @jsonrpc_method()

rhodecode/api/views/user_api.py

@@ -25,7 +25,7 b' from rhodecode.api.utils import ('
     Optional, OAttr, has_superadmin_permission, get_user_or_error, store_update)
 from rhodecode.lib.auth import AuthUser, PasswordGenerator
 from rhodecode.lib.exceptions import DefaultUserException
-from rhodecode.lib.utils2 import safe_int
+from rhodecode.lib.utils2 import safe_int, str2bool
 from rhodecode.model.db import Session, User, Repository
 from rhodecode.model.user import UserModel
 
@@ -81,6 +81,7 b' def get_user(request, apiuser, userid=Op'
                 "usergroup.read",
                 "hg.repogroup.create.false",
                 "hg.create.none",
+                "hg.password_reset.enabled",
                 "hg.extern_activate.manual",
                 "hg.create.write_on_repogroup.false",
                 "hg.usergroup.create.false",
@@ -154,7 +155,8 b' def create_user(request, apiuser, userna'
                 active=Optional(True), admin=Optional(False),
                 extern_name=Optional('rhodecode'),
                 extern_type=Optional('rhodecode'),
-                force_password_change=Optional(False)):
+                force_password_change=Optional(False),
+                create_personal_repo_group=Optional(None)):
     """
     Creates a new user and returns the new user object.
 
@@ -187,7 +189,8 b' def create_user(request, apiuser, userna'
     :param force_password_change: Force the new user to change password
         on next login.
     :type force_password_change: Optional(``True`` | ``False``)
-
+    :param create_personal_repo_group: Create personal repo group for this user
+    :type create_personal_repo_group: Optional(``True`` | ``False``)
     Example output:
 
     .. code-block:: bash
@@ -229,6 +232,9 b' def create_user(request, apiuser, userna'
                 Optional.extract(extern_name) != 'rhodecode'):
         # generate temporary password if user is external
         password = PasswordGenerator().gen_password(length=16)
+    create_repo_group = Optional.extract(create_personal_repo_group)
+    if isinstance(create_repo_group, basestring):
+        create_repo_group = str2bool(create_repo_group)
 
     try:
         user = UserModel().create_or_update(
@@ -242,6 +248,7 b' def create_user(request, apiuser, userna'
             extern_type=Optional.extract(extern_type),
             extern_name=Optional.extract(extern_name),
             force_password_change=Optional.extract(force_password_change),
+            create_repo_group=create_repo_group
         )
         Session().commit()
         return {

rhodecode/authentication/base.py

@@ -226,6 +226,15 b' class RhodeCodeAuthPluginBase(object):'
         """
         raise NotImplementedError("Not implemented in base class")
 
+    def get_url_slug(self):
+        """
+        Returns a slug which should be used when constructing URLs which refer
+        to this plugin. By default it returns the plugin name. If the name is
+        not suitable for using it in an URL the plugin should override this
+        method.
+        """
+        return self.name
+
     @property
     def is_headers_auth(self):
         """

rhodecode/authentication/routes.py

@@ -45,7 +45,7 b' class AuthnPluginResourceBase(AuthnResou'
 
     def __init__(self, plugin):
         self.plugin = plugin
-        self.__name__ = plugin.name
+        self.__name__ = plugin.get_url_slug()
         self.display_name = plugin.get_display_name()
 
 

rhodecode/authentication/views.py

@@ -84,7 +84,7 b' class AuthnPluginViewBase(object):'
 
         try:
             valid_data = schema.deserialize(data)
-        except colander.Invalid, e:
+        except colander.Invalid as e:
             # Display error message and display form again.
             self.request.session.flash(
                 _('Errors exist when saving plugin settings. '

rhodecode/config/middleware.py

@@ -31,9 +31,9 b' from pyramid.authorization import ACLAut'
 from pyramid.config import Configurator
 from pyramid.settings import asbool, aslist
 from pyramid.wsgi import wsgiapp
-from pyramid.httpexceptions import HTTPError, HTTPInternalServerError, HTTPFound
+from pyramid.httpexceptions import (
+    HTTPError, HTTPInternalServerError, HTTPFound)
 from pyramid.events import ApplicationCreated
-import pyramid.httpexceptions as httpexceptions
 from pyramid.renderers import render_to_response
 from routes.middleware import RoutesMiddleware
 import routes.util
@@ -44,10 +44,10 b' from rhodecode.config import patches'
 from rhodecode.config.routing import STATIC_FILE_PREFIX
 from rhodecode.config.environment import (
     load_environment, load_pyramid_environment)
-from rhodecode.lib.exceptions import VCSServerUnavailable
-from rhodecode.lib.vcs.exceptions import VCSCommunicationError
 from rhodecode.lib.middleware import csrf
 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
+from rhodecode.lib.middleware.error_handling import (
+    PylonsErrorHandlingMiddleware)
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.lib.middleware.vcs import VCSMiddleware
 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
@@ -186,53 +186,27 b' def make_not_found_view(config):'
     pylons_app, appenlight_client = wrap_in_appenlight_if_enabled(
         pylons_app, settings)
 
-    # The VCSMiddleware shall operate like a fallback if pyramid doesn't find
-    # a view to handle the request. Therefore we wrap it around the pylons app.
+    # The pylons app is executed inside of the pyramid 404 exception handler.
+    # Exceptions which are raised inside of it are not handled by pyramid
+    # again. Therefore we add a middleware that invokes the error handler in
+    # case of an exception or error response. This way we return proper error
+    # HTML pages in case of an error.
+    reraise = (settings.get('debugtoolbar.enabled', False) or
+               rhodecode.disable_error_handler)
+    pylons_app = PylonsErrorHandlingMiddleware(
+        pylons_app, error_handler, reraise)
+
+    # The VCSMiddleware shall operate like a fallback if pyramid doesn't find a
+    # view to handle the request. Therefore it is wrapped around the pylons
+    # app. It has to be outside of the error handling otherwise error responses
+    # from the vcsserver are converted to HTML error pages. This confuses the
+    # command line tools and the user won't get a meaningful error message.
     if vcs_server_enabled:
         pylons_app = VCSMiddleware(
             pylons_app, settings, appenlight_client, registry=config.registry)
 
-    pylons_app_as_view = wsgiapp(pylons_app)
-
-    def pylons_app_with_error_handler(context, request):
-        """
-        Handle exceptions from rc pylons app:
-
-        - old webob type exceptions get converted to pyramid exceptions
-        - pyramid exceptions are passed to the error handler view
-        """
-        def is_vcs_response(response):
-            return 'X-RhodeCode-Backend' in response.headers
-
-        def is_http_error(response):
-            # webob type error responses
-            return (400 <= response.status_int <= 599)
-
-        def is_error_handling_needed(response):
-            return is_http_error(response) and not is_vcs_response(response)
-
-        try:
-            response = pylons_app_as_view(context, request)
-            if is_error_handling_needed(response):
-                response = webob_to_pyramid_http_response(response)
-                return error_handler(response, request)
-        except HTTPError as e:  # pyramid type exceptions
-            return error_handler(e, request)
-        except Exception as e:
-            log.exception(e)
-
-            if (settings.get('debugtoolbar.enabled', False) or
-                rhodecode.disable_error_handler):
-                raise
-
-            if isinstance(e, VCSCommunicationError):
-                return error_handler(VCSServerUnavailable(), request)
-
-            return error_handler(HTTPInternalServerError(), request)
-
-        return response
-
-    return pylons_app_with_error_handler
+    # Convert WSGI app to pyramid view and return it.
+    return wsgiapp(pylons_app)
 
 
 def add_pylons_compat_data(registry, global_config, settings):
@@ -243,16 +217,6 b' def add_pylons_compat_data(registry, glo'
     registry._pylons_compat_settings = settings
 
 
-def webob_to_pyramid_http_response(webob_response):
-    ResponseClass = httpexceptions.status_map[webob_response.status_int]
-    pyramid_response = ResponseClass(webob_response.status)
-    pyramid_response.status = webob_response.status
-    pyramid_response.headers.update(webob_response.headers)
-    if pyramid_response.headers['content-type'] == 'text/html':
-        pyramid_response.headers['content-type'] = 'text/html; charset=UTF-8'
-    return pyramid_response
-
-
 def error_handler(exception, request):
     from rhodecode.model.settings import SettingsModel
     from rhodecode.lib.utils2 import AttributeDict
@@ -466,10 +430,11 b' def _sanitize_vcs_settings(settings):'
     """
     _string_setting(settings, 'vcs.svn.compatible_version', '')
     _string_setting(settings, 'git_rev_filter', '--all')
-    _string_setting(settings, 'vcs.hooks.protocol', 'pyro4')
+    _string_setting(settings, 'vcs.hooks.protocol', 'http')
+    _string_setting(settings, 'vcs.scm_app_implementation', 'http')
     _string_setting(settings, 'vcs.server', '')
     _string_setting(settings, 'vcs.server.log_level', 'debug')
-    _string_setting(settings, 'vcs.server.protocol', 'pyro4')
+    _string_setting(settings, 'vcs.server.protocol', 'http')
     _bool_setting(settings, 'startup.import_repos', 'false')
     _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
     _bool_setting(settings, 'vcs.server.enable', 'true')
@@ -477,6 +442,13 b' def _sanitize_vcs_settings(settings):'
     _list_setting(settings, 'vcs.backends', 'hg, git, svn')
     _int_setting(settings, 'vcs.connection_timeout', 3600)
 
+    # Support legacy values of vcs.scm_app_implementation. Legacy
+    # configurations may use 'rhodecode.lib.middleware.utils.scm_app_http'
+    # which is now mapped to 'http'.
+    scm_app_impl = settings['vcs.scm_app_implementation']
+    if scm_app_impl == 'rhodecode.lib.middleware.utils.scm_app_http':
+        settings['vcs.scm_app_implementation'] = 'http'
+
 
 def _int_setting(settings, name, default):
     settings[name] = int(settings.get(name, default))
@@ -501,5 +473,8 b' def _list_setting(settings, name, defaul'
         settings[name] = aslist(raw_value)
 
 
-def _string_setting(settings, name, default):
-    settings[name] = settings.get(name, default).lower()
+def _string_setting(settings, name, default, lower=True):
+    value = settings.get(name, default)
+    if lower:
+        value = value.lower()
+    settings[name] = value

rhodecode/config/routing.py

@@ -196,7 +196,7 b' def make_map(config):'
     rmap.connect('user_autocomplete_data', '/_users', controller='home',
                  action='user_autocomplete_data', jsroute=True)
     rmap.connect('user_group_autocomplete_data', '/_user_groups', controller='home',
-                 action='user_group_autocomplete_data')
+                 action='user_group_autocomplete_data', jsroute=True)
 
     rmap.connect(
         'user_profile', '/_profiles/{username}', controller='users',
@@ -305,7 +305,7 b' def make_map(config):'
         m.connect('delete_user', '/users/{user_id}',
                   action='delete', conditions={'method': ['DELETE']})
         m.connect('edit_user', '/users/{user_id}/edit',
-                  action='edit', conditions={'method': ['GET']})
+                  action='edit', conditions={'method': ['GET']}, jsroute=True)
         m.connect('user', '/users/{user_id}',
                   action='show', conditions={'method': ['GET']})
         m.connect('force_password_reset_user', '/users/{user_id}/password_reset',
@@ -389,7 +389,7 b' def make_map(config):'
 
         m.connect('edit_user_group_members',
                   '/user_groups/{user_group_id}/edit/members', jsroute=True,
-                  action='edit_members', conditions={'method': ['GET']})
+                  action='user_group_members', conditions={'method': ['GET']})
 
     # ADMIN PERMISSIONS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
@@ -699,6 +699,9 b' def make_map(config):'
     rmap.connect('repo_refs_changelog_data', '/{repo_name}/refs-data-changelog',
                  controller='summary', action='repo_refs_changelog_data',
                  requirements=URL_NAME_REQUIREMENTS, jsroute=True)
+    rmap.connect('repo_default_reviewers_data', '/{repo_name}/default-reviewers',
+                 controller='summary', action='repo_default_reviewers_data',
+                 jsroute=True, requirements=URL_NAME_REQUIREMENTS)
 
     rmap.connect('changeset_home', '/{repo_name}/changeset/{revision}',
                  controller='changeset', revision='tip', jsroute=True,
@@ -824,6 +827,10 b' def make_map(config):'
                  controller='admin/repos', action='repo_delete_svn_pattern',
                  conditions={'method': ['DELETE'], 'function': check_repo},
                  requirements=URL_NAME_REQUIREMENTS)
+    rmap.connect('repo_pullrequest_settings', '/{repo_name}/settings/pullrequest',
+                 controller='admin/repos', action='repo_settings_pullrequest',
+                 conditions={'method': ['GET', 'POST'], 'function': check_repo},
+                 requirements=URL_NAME_REQUIREMENTS)
 
     # still working url for backward compat.
     rmap.connect('raw_changeset_home_depraced',

rhodecode/controllers/admin/gists.py

@@ -28,10 +28,9 b' import logging'
 
 import formencode
 import peppercorn
-from formencode import htmlfill
 
 from pylons import request, response, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
+from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 from webob.exc import HTTPNotFound, HTTPForbidden
 from sqlalchemy.sql.expression import or_
@@ -45,7 +44,7 b' from rhodecode.lib import helpers as h'
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.auth import LoginRequired, NotAnonymous
 from rhodecode.lib.utils import jsonify
-from rhodecode.lib.utils2 import safe_str, safe_int, time_to_datetime
+from rhodecode.lib.utils2 import time_to_datetime
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.vcs.exceptions import VCSError, NodeNotChangedError
 from rhodecode.model import validation_schema

rhodecode/controllers/admin/my_account.py

@@ -39,19 +39,20 b' from rhodecode.lib.auth import ('
     LoginRequired, NotAnonymous, AuthUser, generate_auth_token)
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import jsonify
-from rhodecode.lib.utils2 import safe_int, md5
+from rhodecode.lib.utils2 import safe_int, md5, str2bool
 from rhodecode.lib.ext_json import json
 
 from rhodecode.model.validation_schema.schemas import user_schema
 from rhodecode.model.db import (
-    Repository, PullRequest, PullRequestReviewers, UserEmailMap, User,
-    UserFollowing)
+    Repository, PullRequest, UserEmailMap, User, UserFollowing)
 from rhodecode.model.forms import UserForm
 from rhodecode.model.scm import RepoList
 from rhodecode.model.user import UserModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.meta import Session
+from rhodecode.model.pull_request import PullRequestModel
+from rhodecode.model.comment import ChangesetCommentsModel
 
 log = logging.getLogger(__name__)
 
@@ -289,25 +290,85 b' class MyAccountController(BaseController'
                 category='success')
         return redirect(url('my_account_emails'))
 
+    def _extract_ordering(self, request):
+        column_index = safe_int(request.GET.get('order[0][column]'))
+        order_dir = request.GET.get('order[0][dir]', 'desc')
+        order_by = request.GET.get(
+            'columns[%s][data][sort]' % column_index, 'name_raw')
+        return order_by, order_dir
+
+    def _get_pull_requests_list(self, statuses):
+        start = safe_int(request.GET.get('start'), 0)
+        length = safe_int(request.GET.get('length'), c.visual.dashboard_items)
+        order_by, order_dir = self._extract_ordering(request)
+
+        pull_requests = PullRequestModel().get_im_participating_in(
+            user_id=c.rhodecode_user.user_id,
+            statuses=statuses,
+            offset=start, length=length, order_by=order_by,
+            order_dir=order_dir)
+
+        pull_requests_total_count = PullRequestModel().count_im_participating_in(
+            user_id=c.rhodecode_user.user_id, statuses=statuses)
+
+        from rhodecode.lib.utils import PartialRenderer
+        _render = PartialRenderer('data_table/_dt_elements.html')
+        data = []
+        for pr in pull_requests:
+            repo_id = pr.target_repo_id
+            comments = ChangesetCommentsModel().get_all_comments(
+                repo_id, pull_request=pr)
+            owned = pr.user_id == c.rhodecode_user.user_id
+            status = pr.calculated_review_status()
+
+            data.append({
+                'target_repo': _render('pullrequest_target_repo',
+                                       pr.target_repo.repo_name),
+                'name': _render('pullrequest_name',
+                                pr.pull_request_id, pr.target_repo.repo_name,
+                                short=True),
+                'name_raw': pr.pull_request_id,
+                'status': _render('pullrequest_status', status),
+                'title': _render(
+                    'pullrequest_title', pr.title, pr.description),
+                'description': h.escape(pr.description),
+                'updated_on': _render('pullrequest_updated_on',
+                                      h.datetime_to_time(pr.updated_on)),
+                'updated_on_raw': h.datetime_to_time(pr.updated_on),
+                'created_on': _render('pullrequest_updated_on',
+                                      h.datetime_to_time(pr.created_on)),
+                'created_on_raw': h.datetime_to_time(pr.created_on),
+                'author': _render('pullrequest_author',
+                                  pr.author.full_contact, ),
+                'author_raw': pr.author.full_name,
+                'comments': _render('pullrequest_comments', len(comments)),
+                'comments_raw': len(comments),
+                'closed': pr.is_closed(),
+                'owned': owned
+            })
+        # json used to render the grid
+        data = ({
+            'data': data,
+            'recordsTotal': pull_requests_total_count,
+            'recordsFiltered': pull_requests_total_count,
+        })
+        return data
+
     def my_account_pullrequests(self):
         c.active = 'pullrequests'
         self.__load_data()
-        c.show_closed = request.GET.get('pr_show_closed')
-
-        def _filter(pr):
-            s = sorted(pr, key=lambda o: o.created_on, reverse=True)
-            if not c.show_closed:
-                s = filter(lambda p: p.status != PullRequest.STATUS_CLOSED, s)
-            return s
+        c.show_closed = str2bool(request.GET.get('pr_show_closed'))
 
-        c.my_pull_requests = _filter(
-            PullRequest.query().filter(
-                PullRequest.user_id == c.rhodecode_user.user_id).all())
-        my_prs = [
-            x.pull_request for x in PullRequestReviewers.query().filter(
-                PullRequestReviewers.user_id == c.rhodecode_user.user_id).all()]
-        c.participate_in_pull_requests = _filter(my_prs)
-        return render('admin/my_account/my_account.html')
+        statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
+        if c.show_closed:
+            statuses += [PullRequest.STATUS_CLOSED]
+        data = self._get_pull_requests_list(statuses)
+        if not request.is_xhr:
+            c.data_participate = json.dumps(data['data'])
+            c.records_total_participate = data['recordsTotal']
+            return render('admin/my_account/my_account.html')
+        else:
+            return json.dumps(data)
 
     def my_account_auth_tokens(self):
         c.active = 'auth_tokens'

rhodecode/controllers/admin/permissions.py

@@ -57,7 +57,7 b' class PermissionsController(BaseControll'
         super(PermissionsController, self).__before__()
 
     def __load_data(self):
-        PermissionModel().set_global_permission_choices(c, translator=_)
+        PermissionModel().set_global_permission_choices(c, gettext_translator=_)
 
     @HasPermissionAllDecorator('hg.admin')
     def permission_application(self):
@@ -92,6 +92,7 b' class PermissionsController(BaseControll'
         self.__load_data()
         _form = ApplicationPermissionsForm(
             [x[0] for x in c.register_choices],
+            [x[0] for x in c.password_reset_choices],
             [x[0] for x in c.extern_activate_choices])()
 
         try:

rhodecode/controllers/admin/repos.py

@@ -160,6 +160,7 b' class ReposController(BaseRepoController'
         self.__load_defaults()
         form_result = {}
         task_id = None
+        c.personal_repo_group = c.rhodecode_user.personal_repo_group
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form_result = RepoForm(repo_groups=c.repo_groups_choices,
@@ -173,8 +174,6 b' class ReposController(BaseRepoController'
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
-            c.personal_repo_group = RepoGroup.get_by_group_name(
-                c.rhodecode_user.username)
             return htmlfill.render(
                 render('admin/repos/repo_add.html'),
                 defaults=errors.value,
@@ -215,7 +214,7 b' class ReposController(BaseRepoController'
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
-        c.personal_repo_group = RepoGroup.get_by_group_name(c.rhodecode_user.username)
+        c.personal_repo_group = c.rhodecode_user.personal_repo_group
         c.new_repo = repo_name_slug(new_repo)
 
         ## apply the defaults from defaults page
@@ -299,9 +298,8 b' class ReposController(BaseRepoController'
         repo_model = RepoModel()
         changed_name = repo_name
 
+        c.personal_repo_group = c.rhodecode_user.personal_repo_group
         # override the choices with extracted revisions !
-        c.personal_repo_group = RepoGroup.get_by_group_name(
-            c.rhodecode_user.username)
         repo = Repository.get_by_repo_name(repo_name)
         old_data = {
             'repo_name': repo_name,
@@ -399,8 +397,7 b' class ReposController(BaseRepoController'
 
         c.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == c.repo_info).all()
-        c.personal_repo_group = RepoGroup.get_by_group_name(
-            c.rhodecode_user.username)
+        c.personal_repo_group = c.rhodecode_user.personal_repo_group
         c.active = 'settings'
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),

rhodecode/controllers/admin/settings.py

@@ -34,6 +34,7 b' import packaging.version'
 from pylons import request, tmpl_context as c, url, config
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _, lazy_ugettext
+from pyramid.threadlocal import get_current_registry
 from webob.exc import HTTPBadRequest
 
 import rhodecode
@@ -54,6 +55,7 b' from rhodecode.model.db import RhodeCode'
 from rhodecode.model.forms import ApplicationSettingsForm, \
     ApplicationUiSettingsForm, ApplicationVisualisationForm, \
     LabsSettingsForm, IssueTrackerPatternsForm
+from rhodecode.model.repo_group import RepoGroupModel
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.notification import EmailNotificationModel
@@ -63,6 +65,7 b' from rhodecode.model.settings import ('
     SettingsModel)
 
 from rhodecode.model.supervisor import SupervisorModel, SUPERVISOR_MASTER
+from rhodecode.svn_support.config_keys import generate_config
 
 
 log = logging.getLogger(__name__)
@@ -134,6 +137,10 b' class SettingsController(BaseController)'
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
+        # TODO: Replace with request.registry after migrating to pyramid.
+        pyramid_settings = get_current_registry().settings
+        c.svn_proxy_generate_config = pyramid_settings[generate_config]
+
         application_form = ApplicationUiSettingsForm()()
 
         try:
@@ -186,6 +193,10 b' class SettingsController(BaseController)'
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
+        # TODO: Replace with request.registry after migrating to pyramid.
+        pyramid_settings = get_current_registry().settings
+        c.svn_proxy_generate_config = pyramid_settings[generate_config]
+
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
@@ -235,6 +246,8 b' class SettingsController(BaseController)'
         """POST /admin/settings/global: All items in the collection"""
         # url('admin_settings_global')
         c.active = 'global'
+        c.personal_repo_group_default_pattern = RepoGroupModel()\
+            .get_personal_group_name_pattern()
         application_form = ApplicationSettingsForm()()
         try:
             form_result = application_form.to_python(dict(request.POST))
@@ -249,16 +262,18 b' class SettingsController(BaseController)'
 
         try:
             settings = [
-                ('title', 'rhodecode_title'),
-                ('realm', 'rhodecode_realm'),
-                ('pre_code', 'rhodecode_pre_code'),
-                ('post_code', 'rhodecode_post_code'),
-                ('captcha_public_key', 'rhodecode_captcha_public_key'),
-                ('captcha_private_key', 'rhodecode_captcha_private_key'),
+                ('title', 'rhodecode_title', 'unicode'),
+                ('realm', 'rhodecode_realm', 'unicode'),
+                ('pre_code', 'rhodecode_pre_code', 'unicode'),
+                ('post_code', 'rhodecode_post_code', 'unicode'),
+                ('captcha_public_key', 'rhodecode_captcha_public_key', 'unicode'),
+                ('captcha_private_key', 'rhodecode_captcha_private_key', 'unicode'),
+                ('create_personal_repo_group', 'rhodecode_create_personal_repo_group', 'bool'),
+                ('personal_repo_group_pattern', 'rhodecode_personal_repo_group_pattern', 'unicode'),
             ]
-            for setting, form_key in settings:
+            for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
-                    setting, form_result[form_key])
+                    setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
@@ -277,6 +292,8 b' class SettingsController(BaseController)'
         """GET /admin/settings/global: All items in the collection"""
         # url('admin_settings_global')
         c.active = 'global'
+        c.personal_repo_group_default_pattern = RepoGroupModel()\
+            .get_personal_group_name_pattern()
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
@@ -397,19 +414,20 b' class SettingsController(BaseController)'
         settings_model = IssueTrackerSettingsModel()
 
         form = IssueTrackerPatternsForm()().to_python(request.POST)
-        for uid in form['delete_patterns']:
-            settings_model.delete_entries(uid)
+        if form:
+            for uid in form.get('delete_patterns', []):
+                settings_model.delete_entries(uid)
 
-        for pattern in form['patterns']:
-            for setting, value, type_ in pattern:
-                sett = settings_model.create_or_update_setting(
-                    setting, value, type_)
-                Session().add(sett)
+            for pattern in form.get('patterns', []):
+                for setting, value, type_ in pattern:
+                    sett = settings_model.create_or_update_setting(
+                        setting, value, type_)
+                    Session().add(sett)
 
-            Session().commit()
+                Session().commit()
 
-        SettingsModel().invalidate_settings_cache()
-        h.flash(_('Updated issue tracker entries'), category='success')
+            SettingsModel().invalidate_settings_cache()
+            h.flash(_('Updated issue tracker entries'), category='success')
         return redirect(url('admin_settings_issuetracker'))
 
     @HasPermissionAllDecorator('hg.admin')
@@ -530,65 +548,93 b' class SettingsController(BaseController)'
         """GET /admin/settings/system: All items in the collection"""
         # url('admin_settings_system')
         snapshot = str2bool(request.GET.get('snapshot'))
-        c.active = 'system'
+        defaults = self._form_defaults()
 
-        defaults = self._form_defaults()
-        c.rhodecode_ini = rhodecode.CONFIG
+        c.active = 'system'
         c.rhodecode_update_url = defaults.get('rhodecode_update_url')
         server_info = ScmModel().get_server_info(request.environ)
+
         for key, val in server_info.iteritems():
             setattr(c, key, val)
 
-        if c.disk['percent'] > 90:
-            h.flash(h.literal(_(
-                'Critical: your disk space is very low <b>%s%%</b> used' %
-                c.disk['percent'])), 'error')
-        elif c.disk['percent'] > 70:
-            h.flash(h.literal(_(
-                'Warning: your disk space is running low <b>%s%%</b> used' %
-                c.disk['percent'])), 'warning')
+        def val(name, subkey='human_value'):
+            return server_info[name][subkey]
+
+        def state(name):
+            return server_info[name]['state']
+
+        def val2(name):
+            val = server_info[name]['human_value']
+            state = server_info[name]['state']
+            return val, state
 
-        try:
-            c.uptime_age = h._age(
-                h.time_to_datetime(c.boot_time), False, show_suffix=False)
-        except TypeError:
-            c.uptime_age = c.boot_time
+        c.data_items = [
+            # update info
+            (_('Update info'), h.literal(
+                '<span class="link" id="check_for_update" >%s.</span>' % (
+                _('Check for updates')) +
+                '<br/> <span >%s.</span>' % (_('Note: please make sure this server can access `%s` for the update link to work') % c.rhodecode_update_url)
+            ), ''),
+
+            # RhodeCode specific
+            (_('RhodeCode Version'), val('rhodecode_app')['text'], state('rhodecode_app')),
+            (_('RhodeCode Server IP'), val('server')['server_ip'], state('server')),
+            (_('RhodeCode Server ID'), val('server')['server_id'], state('server')),
+            (_('RhodeCode Configuration'), val('rhodecode_config')['path'], state('rhodecode_config')),
+            ('', '', ''),  # spacer
+
+            # Database
+            (_('Database'), val('database')['url'], state('database')),
+            (_('Database version'), val('database')['version'], state('database')),
+            ('', '', ''),  # spacer
 
-        try:
-            c.system_memory = '%s/%s, %s%% (%s%%) used%s' % (
-                h.format_byte_size_binary(c.memory['used']),
-                h.format_byte_size_binary(c.memory['total']),
-                c.memory['percent2'],
-                c.memory['percent'],
-                ' %s' % c.memory['error'] if 'error' in c.memory else '')
-        except TypeError:
-            c.system_memory = 'NOT AVAILABLE'
+            # Platform/Python
+            (_('Platform'), val('platform')['name'], state('platform')),
+            (_('Platform UUID'), val('platform')['uuid'], state('platform')),
+            (_('Python version'), val('python')['version'], state('python')),
+            (_('Python path'), val('python')['executable'], state('python')),
+            ('', '', ''),  # spacer
+
+            # Systems stats
+            (_('CPU'), val('cpu'), state('cpu')),
+            (_('Load'), val('load')['text'], state('load')),
+            (_('Memory'), val('memory')['text'], state('memory')),
+            (_('Uptime'), val('uptime')['text'], state('uptime')),
+            ('', '', ''),  # spacer
+
+            # Repo storage
+            (_('Storage location'), val('storage')['path'], state('storage')),
+            (_('Storage info'), val('storage')['text'], state('storage')),
+            (_('Storage inodes'), val('storage_inodes')['text'], state('storage_inodes')),
 
-        rhodecode_ini_safe = rhodecode.CONFIG.copy()
-        blacklist = [
-            'rhodecode_license_key',
-            'routes.map',
-            'pylons.h',
-            'pylons.app_globals',
-            'pylons.environ_config',
-            'sqlalchemy.db1.url',
-            ('app_conf', 'sqlalchemy.db1.url')
+            (_('Gist storage location'), val('storage_gist')['path'], state('storage_gist')),
+            (_('Gist storage info'), val('storage_gist')['text'], state('storage_gist')),
+
+            (_('Archive cache storage location'), val('storage_archive')['path'], state('storage_archive')),
+            (_('Archive cache info'), val('storage_archive')['text'], state('storage_archive')),
+
+            (_('Temp storage location'), val('storage_temp')['path'], state('storage_temp')),
+            (_('Temp storage info'), val('storage_temp')['text'], state('storage_temp')),
+
+            (_('Search info'), val('search')['text'], state('search')),
+            (_('Search location'), val('search')['location'], state('search')),
+            ('', '', ''),  # spacer
+
+            # VCS specific
+            (_('VCS Backends'), val('vcs_backends'), state('vcs_backends')),
+            (_('VCS Server'), val('vcs_server')['text'], state('vcs_server')),
+            (_('GIT'), val('git'), state('git')),
+            (_('HG'), val('hg'), state('hg')),
+            (_('SVN'), val('svn'), state('svn')),
+
         ]
-        for k in blacklist:
-            if isinstance(k, tuple):
-                section, key = k
-                if section in rhodecode_ini_safe:
-                    rhodecode_ini_safe[section].pop(key, None)
-            else:
-                rhodecode_ini_safe.pop(k, None)
-
-        c.rhodecode_ini_safe = rhodecode_ini_safe
 
         # TODO: marcink, figure out how to allow only selected users to do this
-        c.allowed_to_snapshot = False
+        c.allowed_to_snapshot = c.rhodecode_user.admin
 
         if snapshot:
             if c.allowed_to_snapshot:
+                c.data_items.pop(0)  # remove server info
                 return render('admin/settings/settings_system_snapshot.html')
             else:
                 h.flash('You are not allowed to do this', category='warning')

rhodecode/controllers/admin/user_groups.py

@@ -25,6 +25,7 b' User Groups crud controller for pylons'
 import logging
 import formencode
 
+import peppercorn
 from formencode import htmlfill
 from pylons import request, tmpl_context as c, url, config
 from pylons.controllers.util import redirect
@@ -40,7 +41,7 b' from rhodecode.lib.utils import jsonify,'
 from rhodecode.lib.utils2 import safe_unicode, str2bool, safe_int
 from rhodecode.lib.auth import (
     LoginRequired, NotAnonymous, HasUserGroupPermissionAnyDecorator,
-    HasPermissionAnyDecorator)
+    HasPermissionAnyDecorator, XHRRequired)
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.scm import UserGroupList
@@ -64,18 +65,13 b' class UserGroupsController(BaseControlle'
     def __before__(self):
         super(UserGroupsController, self).__before__()
         c.available_permissions = config['available_permissions']
-        PermissionModel().set_global_permission_choices(c, translator=_)
+        PermissionModel().set_global_permission_choices(c, gettext_translator=_)
 
     def __load_data(self, user_group_id):
         c.group_members_obj = [x.user for x in c.user_group.members]
         c.group_members_obj.sort(key=lambda u: u.username.lower())
-
         c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
 
-        c.available_members = [(x.user_id, x.username)
-                               for x in User.query().all()]
-        c.available_members.sort(key=lambda u: u[1].lower())
-
     def __load_defaults(self, user_group_id):
         """
         Load defaults settings for edit, and update
@@ -207,20 +203,21 b' class UserGroupsController(BaseControlle'
         c.active = 'settings'
         self.__load_data(user_group_id)
 
-        available_members = [safe_unicode(x[0]) for x in c.available_members]
-
         users_group_form = UserGroupForm(
-            edit=True, old_data=c.user_group.get_dict(),
-            available_members=available_members, allow_disabled=True)()
+            edit=True, old_data=c.user_group.get_dict(), allow_disabled=True)()
 
         try:
             form_result = users_group_form.to_python(request.POST)
+            pstruct = peppercorn.parse(request.POST.items())
+            form_result['users_group_members'] = pstruct['user_group_members']
+
             UserGroupModel().update(c.user_group, form_result)
-            gr = form_result['users_group_name']
+            updated_user_group = form_result['users_group_name']
             action_logger(c.rhodecode_user,
-                          'admin_updated_users_group:%s' % gr,
+                          'admin_updated_users_group:%s' % updated_user_group,
                           None, self.ip_addr, self.sa)
-            h.flash(_('Updated user group %s') % gr, category='success')
+            h.flash(_('Updated user group %s') % updated_user_group,
+                    category='success')
             Session().commit()
         except formencode.Invalid as errors:
             defaults = errors.value
@@ -462,19 +459,29 b' class UserGroupsController(BaseControlle'
         return render('admin/user_groups/user_group_edit.html')
 
     @HasUserGroupPermissionAnyDecorator('usergroup.admin')
-    def edit_members(self, user_group_id):
+    @XHRRequired()
+    @jsonify
+    def user_group_members(self, user_group_id):
         user_group_id = safe_int(user_group_id)
-        c.user_group = UserGroup.get_or_404(user_group_id)
-        c.active = 'members'
-        c.group_members_obj = sorted((x.user for x in c.user_group.members),
-                                     key=lambda u: u.username.lower())
+        user_group = UserGroup.get_or_404(user_group_id)
+        group_members_obj = sorted((x.user for x in user_group.members),
+                                   key=lambda u: u.username.lower())
 
-        group_members = [(x.user_id, x.username) for x in c.group_members_obj]
+        group_members = [
+            {
+                'id': user.user_id,
+                'first_name': user.name,
+                'last_name': user.lastname,
+                'username': user.username,
+                'icon_link': h.gravatar_url(user.email, 30),
+                'value_display': h.person(user.email),
+                'value': user.username,
+                'value_type': 'user',
+                'active': user.active,
+            }
+            for user in group_members_obj
+        ]
 
-        if request.is_xhr:
-            return jsonify(lambda *a, **k: {
-                'members': group_members
-            })
-
-        c.group_members = group_members
-        return render('admin/user_groups/user_group_edit.html')
+        return {
+            'members': group_members
+        }

rhodecode/controllers/admin/users.py

@@ -45,12 +45,13 b' from rhodecode.model.db import ('
     PullRequestReviewers, User, UserEmailMap, UserIpMap, RepoGroup)
 from rhodecode.model.forms import (
     UserForm, UserPermissionsForm, UserIndividualPermissionsForm)
+from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.meta import Session
 from rhodecode.model.permission import PermissionModel
 from rhodecode.lib.utils import action_logger
 from rhodecode.lib.ext_json import json
-from rhodecode.lib.utils2 import datetime_to_time, safe_int
+from rhodecode.lib.utils2 import datetime_to_time, safe_int, AttributeDict
 
 log = logging.getLogger(__name__)
 
@@ -73,7 +74,7 b' class UsersController(BaseController):'
             ('ru', 'Russian (ru)'),
             ('zh', 'Chinese (zh)'),
         ]
-        PermissionModel().set_global_permission_choices(c, translator=_)
+        PermissionModel().set_global_permission_choices(c, gettext_translator=_)
 
     @HasPermissionAllDecorator('hg.admin')
     def index(self):
@@ -120,6 +121,16 b' class UsersController(BaseController):'
         c.data = json.dumps(users_data)
         return render('admin/users/users.html')
 
+    def _get_personal_repo_group_template_vars(self):
+        DummyUser = AttributeDict({
+            'username': '${username}',
+            'user_id': '${user_id}',
+        })
+        c.default_create_repo_group = RepoGroupModel() \
+            .get_default_create_personal_repo_group()
+        c.personal_repo_group_name = RepoGroupModel() \
+            .get_personal_group_name(DummyUser)
+
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def create(self):
@@ -143,6 +154,7 b' class UsersController(BaseController):'
                               % {'user_link': user_link}), category='success')
             Session().commit()
         except formencode.Invalid as errors:
+            self._get_personal_repo_group_template_vars()
             return htmlfill.render(
                 render('admin/users/user_add.html'),
                 defaults=errors.value,
@@ -163,6 +175,7 b' class UsersController(BaseController):'
         """GET /users/new: Form to create a new item"""
         # url('new_user')
         c.default_extern_type = auth_rhodecode.RhodeCodeAuthPlugin.name
+        self._get_personal_repo_group_template_vars()
         return render('admin/users/user_add.html')
 
     @HasPermissionAllDecorator('hg.admin')
@@ -339,22 +352,41 b' class UsersController(BaseController):'
 
         user_id = safe_int(user_id)
         c.user = User.get_or_404(user_id)
+        personal_repo_group = RepoGroup.get_user_personal_repo_group(
+            c.user.user_id)
+        if personal_repo_group:
+            return redirect(url('edit_user_advanced', user_id=user_id))
 
+        personal_repo_group_name = RepoGroupModel().get_personal_group_name(
+            c.user)
+        named_personal_group = RepoGroup.get_by_group_name(
+            personal_repo_group_name)
         try:
-            desc = RepoGroupModel.PERSONAL_GROUP_DESC % {
-                'username': c.user.username}
-            if not RepoGroup.get_by_group_name(c.user.username):
-                RepoGroupModel().create(group_name=c.user.username,
-                                        group_description=desc,
-                                        owner=c.user.username)
 
-                msg = _('Created repository group `%s`' % (c.user.username,))
+            if named_personal_group and named_personal_group.user_id == c.user.user_id:
+                # migrate the same named group, and mark it as personal
+                named_personal_group.personal = True
+                Session().add(named_personal_group)
+                Session().commit()
+                msg = _('Linked repository group `%s` as personal' % (
+                    personal_repo_group_name,))
                 h.flash(msg, category='success')
+            elif not named_personal_group:
+                RepoGroupModel().create_personal_repo_group(c.user)
+
+                msg = _('Created repository group `%s`' % (
+                    personal_repo_group_name,))
+                h.flash(msg, category='success')
+            else:
+                msg = _('Repository group `%s` is already taken' % (
+                    personal_repo_group_name,))
+                h.flash(msg, category='warning')
         except Exception:
             log.exception("Exception during repository group creation")
             msg = _(
                 'An error occurred during repository group creation for user')
             h.flash(msg, category='error')
+            Session().rollback()
 
         return redirect(url('edit_user_advanced', user_id=user_id))
 
@@ -397,7 +429,9 b' class UsersController(BaseController):'
 
         c.active = 'advanced'
         c.perm_user = AuthUser(user_id=user_id, ip_addr=self.ip_addr)
-        c.personal_repo_group = RepoGroup.get_by_group_name(user.username)
+        c.personal_repo_group = c.perm_user.personal_repo_group
+        c.personal_repo_group_name = RepoGroupModel()\
+            .get_personal_group_name(user)
         c.first_admin = User.get_first_super_admin()
         defaults = user.get_dict()
 

rhodecode/controllers/changeset.py

@@ -32,7 +32,7 b' from pylons.i18n.translation import _'
 from pylons.controllers.util import redirect
 
 from rhodecode.lib import auth
-from rhodecode.lib import diffs
+from rhodecode.lib import diffs, codeblocks
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous)
 from rhodecode.lib.base import BaseRepoController, render
@@ -43,7 +43,7 b' from rhodecode.lib.utils import action_l'
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
-    RepositoryError, CommitDoesNotExistError)
+    RepositoryError, CommitDoesNotExistError, NodeDoesNotExistError)
 from rhodecode.model.db import ChangesetComment, ChangesetStatus
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
@@ -156,15 +156,24 b' class ChangesetController(BaseRepoContro'
         c.ignorews_url = _ignorews_url
         c.context_url = _context_url
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
+
+        # fetch global flags of ignore ws or context lines
+        context_lcl = get_line_ctx('', request.GET)
+        ign_whitespace_lcl = get_ignore_ws('', request.GET)
+
+        # diff_limit will cut off the whole diff if the limit is applied
+        # otherwise it will just hide the big files from the front-end
+        diff_limit = self.cut_off_limit_diff
+        file_limit = self.cut_off_limit_file
+
         # get ranges of commit ids if preset
         commit_range = commit_id_range.split('...')[:2]
-        enable_comments = True
+
         try:
             pre_load = ['affected_files', 'author', 'branch', 'date',
                         'message', 'parents']
 
             if len(commit_range) == 2:
-                enable_comments = False
                 commits = c.rhodecode_repo.get_commits(
                     start_id=commit_range[0], end_id=commit_range[1],
                     pre_load=pre_load)
@@ -190,88 +199,78 b' class ChangesetController(BaseRepoContro'
         c.lines_deleted = 0
 
         c.commit_statuses = ChangesetStatus.STATUSES
-        c.comments = []
-        c.statuses = []
         c.inline_comments = []
         c.inline_cnt = 0
         c.files = []
 
+        c.statuses = []
+        c.comments = []
+        if len(c.commit_ranges) == 1:
+            commit = c.commit_ranges[0]
+            c.comments = ChangesetCommentsModel().get_comments(
+                c.rhodecode_db_repo.repo_id,
+                revision=commit.raw_id)
+            c.statuses.append(ChangesetStatusModel().get_status(
+                c.rhodecode_db_repo.repo_id, commit.raw_id))
+            # comments from PR
+            statuses = ChangesetStatusModel().get_statuses(
+                c.rhodecode_db_repo.repo_id, commit.raw_id,
+                with_revisions=True)
+            prs = set(st.pull_request for st in statuses
+                      if st.pull_request is not None)
+            # from associated statuses, check the pull requests, and
+            # show comments from them
+            for pr in prs:
+                c.comments.extend(pr.comments)
+
         # Iterate over ranges (default commit view is always one commit)
         for commit in c.commit_ranges:
-            if method == 'show':
-                c.statuses.extend([ChangesetStatusModel().get_status(
-                    c.rhodecode_db_repo.repo_id, commit.raw_id)])
-
-                c.comments.extend(ChangesetCommentsModel().get_comments(
-                    c.rhodecode_db_repo.repo_id,
-                    revision=commit.raw_id))
-
-                # comments from PR
-                st = ChangesetStatusModel().get_statuses(
-                    c.rhodecode_db_repo.repo_id, commit.raw_id,
-                    with_revisions=True)
-
-                # from associated statuses, check the pull requests, and
-                # show comments from them
-
-                prs = set(x.pull_request for x in
-                          filter(lambda x: x.pull_request is not None, st))
-                for pr in prs:
-                    c.comments.extend(pr.comments)
-
-                inlines = ChangesetCommentsModel().get_inline_comments(
-                    c.rhodecode_db_repo.repo_id, revision=commit.raw_id)
-                c.inline_comments.extend(inlines.iteritems())
-
             c.changes[commit.raw_id] = []
 
             commit2 = commit
             commit1 = commit.parents[0] if commit.parents else EmptyCommit()
 
-            # fetch global flags of ignore ws or context lines
-            context_lcl = get_line_ctx('', request.GET)
-            ign_whitespace_lcl = get_ignore_ws('', request.GET)
-
             _diff = c.rhodecode_repo.get_diff(
                 commit1, commit2,
                 ignore_whitespace=ign_whitespace_lcl, context=context_lcl)
+            diff_processor = diffs.DiffProcessor(
+                _diff, format='newdiff', diff_limit=diff_limit,
+                file_limit=file_limit, show_full_diff=fulldiff)
 
-            # diff_limit will cut off the whole diff if the limit is applied
-            # otherwise it will just hide the big files from the front-end
-            diff_limit = self.cut_off_limit_diff
-            file_limit = self.cut_off_limit_file
-
-            diff_processor = diffs.DiffProcessor(
-                _diff, format='gitdiff', diff_limit=diff_limit,
-                file_limit=file_limit, show_full_diff=fulldiff)
             commit_changes = OrderedDict()
             if method == 'show':
                 _parsed = diff_processor.prepare()
                 c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
-                for f in _parsed:
-                    c.files.append(f)
-                    st = f['stats']
-                    c.lines_added += st['added']
-                    c.lines_deleted += st['deleted']
-                    fid = h.FID(commit.raw_id, f['filename'])
-                    diff = diff_processor.as_html(enable_comments=enable_comments,
-                                                  parsed_lines=[f])
-                    commit_changes[fid] = [
-                        commit1.raw_id, commit2.raw_id,
-                        f['operation'], f['filename'], diff, st, f]
+
+                _parsed = diff_processor.prepare()
+
+                def _node_getter(commit):
+                    def get_node(fname):
+                        try:
+                            return commit.get_node(fname)
+                        except NodeDoesNotExistError:
+                            return None
+                    return get_node
+
+                inline_comments = ChangesetCommentsModel().get_inline_comments(
+                    c.rhodecode_db_repo.repo_id, revision=commit.raw_id)
+                c.inline_cnt += len(inline_comments)
+
+                diffset = codeblocks.DiffSet(
+                    repo_name=c.repo_name,
+                    source_node_getter=_node_getter(commit1),
+                    target_node_getter=_node_getter(commit2),
+                    comments=inline_comments
+                ).render_patchset(_parsed, commit1.raw_id, commit2.raw_id)
+                c.changes[commit.raw_id] = diffset
             else:
                 # downloads/raw we only need RAW diff nothing else
                 diff = diff_processor.as_raw()
-                commit_changes[''] = [None, None, None, None, diff, None, None]
-            c.changes[commit.raw_id] = commit_changes
+                c.changes[commit.raw_id] = [None, None, None, None, diff, None, None]
 
         # sort comments by how they were generated
         c.comments = sorted(c.comments, key=lambda x: x.comment_id)
 
-        # count inline comments
-        for __, lines in c.inline_comments:
-            for comments in lines.values():
-                c.inline_cnt += len(comments)
 
         if len(c.commit_ranges) == 1:
             c.commit = c.commit_ranges[0]

rhodecode/controllers/compare.py

@@ -31,13 +31,14 b' from pylons.i18n.translation import _'
 
 from rhodecode.controllers.utils import parse_path_ref, get_commit_from_ref_name
 from rhodecode.lib import helpers as h
-from rhodecode.lib import diffs
+from rhodecode.lib import diffs, codeblocks
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import safe_str
 from rhodecode.lib.utils2 import safe_unicode, str2bool
 from rhodecode.lib.vcs.exceptions import (
-    EmptyRepositoryError, RepositoryError, RepositoryRequirementError)
+    EmptyRepositoryError, RepositoryError, RepositoryRequirementError,
+    NodeDoesNotExistError)
 from rhodecode.model.db import Repository, ChangesetStatus
 
 log = logging.getLogger(__name__)
@@ -78,7 +79,7 b' class CompareController(BaseRepoControll'
     def index(self, repo_name):
         c.compare_home = True
         c.commit_ranges = []
-        c.files = []
+        c.diffset = None
         c.limited_diff = False
         source_repo = c.rhodecode_db_repo.repo_name
         target_repo = request.GET.get('target_repo', source_repo)
@@ -239,28 +240,24 b' class CompareController(BaseRepoControll'
             commit1=source_commit, commit2=target_commit,
             path1=source_path, path=target_path)
         diff_processor = diffs.DiffProcessor(
-            txtdiff, format='gitdiff', diff_limit=diff_limit,
+            txtdiff, format='newdiff', diff_limit=diff_limit,
             file_limit=file_limit, show_full_diff=c.fulldiff)
         _parsed = diff_processor.prepare()
 
-        c.limited_diff = False
-        if isinstance(_parsed, diffs.LimitedDiffContainer):
-            c.limited_diff = True
+        def _node_getter(commit):
+            """ Returns a function that returns a node for a commit or None """
+            def get_node(fname):
+                try:
+                    return commit.get_node(fname)
+                except NodeDoesNotExistError:
+                    return None
+            return get_node
 
-        c.files = []
-        c.changes = {}
-        c.lines_added = 0
-        c.lines_deleted = 0
-        for f in _parsed:
-            st = f['stats']
-            if not st['binary']:
-                c.lines_added += st['added']
-                c.lines_deleted += st['deleted']
-            fid = h.FID('', f['filename'])
-            c.files.append([fid, f['operation'], f['filename'], f['stats'], f])
-            htmldiff = diff_processor.as_html(
-                enable_comments=False, parsed_lines=[f])
-            c.changes[fid] = [f['operation'], f['filename'], htmldiff, f]
+        c.diffset = codeblocks.DiffSet(
+            repo_name=source_repo.repo_name,
+            source_node_getter=_node_getter(source_commit),
+            target_node_getter=_node_getter(target_commit),
+        ).render_patchset(_parsed, source_ref, target_ref)
 
         c.preview_mode = merge
 

rhodecode/controllers/files.py

@@ -36,6 +36,8 b' from webob.exc import HTTPNotFound, HTTP'
 from rhodecode.controllers.utils import parse_path_ref
 from rhodecode.lib import diffs, helpers as h, caches
 from rhodecode.lib.compat import OrderedDict
+from rhodecode.lib.codeblocks import (
+    filenode_as_lines_tokens, filenode_as_annotated_lines_tokens)
 from rhodecode.lib.utils import jsonify, action_logger
 from rhodecode.lib.utils2 import (
     convert_line_endings, detect_mode, safe_str, str2bool)
@@ -221,9 +223,19 b' class FilesController(BaseRepoController'
             c.file_author = True
             c.file_tree = ''
             if c.file.is_file():
-                c.renderer = (
-                    c.renderer and h.renderer_from_filename(c.file.path))
+                c.file_source_page = 'true'
                 c.file_last_commit = c.file.last_commit
+                if c.file.size < self.cut_off_limit_file:
+                    if c.annotate:  # annotation has precedence over renderer
+                        c.annotated_lines = filenode_as_annotated_lines_tokens(
+                            c.file
+                        )
+                    else:
+                        c.renderer = (
+                            c.renderer and h.renderer_from_filename(c.file.path)
+                        )
+                        if not c.renderer:
+                            c.lines = filenode_as_lines_tokens(c.file)
 
                 c.on_branch_head = self._is_valid_head(
                     commit_id, c.rhodecode_repo)
@@ -233,6 +245,7 b' class FilesController(BaseRepoController'
                 c.authors = [(h.email(author),
                               h.person(author, 'username_or_name_or_email'))]
             else:
+                c.file_source_page = 'false'
                 c.authors = []
                 c.file_tree = self._get_tree_at_commit(
                     repo_name, c.commit.raw_id, f_path)

rhodecode/controllers/forks.py

@@ -60,8 +60,7 b' class ForksController(BaseRepoController'
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.landing_revs_choices = choices
-        c.personal_repo_group = RepoGroup.get_by_group_name(
-            c.rhodecode_user.username)
+        c.personal_repo_group = c.rhodecode_user.personal_repo_group
 
     def __load_data(self, repo_name=None):
         """

rhodecode/controllers/home.py

@@ -286,4 +286,3 b' class HomeController(BaseController):'
         _user_groups = _user_groups
 
         return {'suggestions': _user_groups}
-

rhodecode/controllers/pullrequests.py

@@ -22,6 +22,7 b''
 pull requests controller for rhodecode for initializing pull requests
 """
 
+import peppercorn
 import formencode
 import logging
 
@@ -29,22 +30,26 b' from webob.exc import HTTPNotFound, HTTP'
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
+from pyramid.threadlocal import get_current_registry
 from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import or_
 
 from rhodecode import events
-from rhodecode.lib import auth, diffs, helpers as h
+from rhodecode.lib import auth, diffs, helpers as h, codeblocks
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.base import (
     BaseRepoController, render, vcs_operation_context)
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasAcceptedRepoType, XHRRequired)
+from rhodecode.lib.channelstream import channelstream_request
+from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.utils import jsonify
 from rhodecode.lib.utils2 import safe_int, safe_str, str2bool, safe_unicode
-from rhodecode.lib.vcs.backends.base import EmptyCommit
+from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
 from rhodecode.lib.vcs.exceptions import (
-    EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError)
+    EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
+    NodeDoesNotExistError)
 from rhodecode.lib.diffs import LimitedDiffContainer
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
@@ -61,7 +66,7 b' class PullrequestsController(BaseRepoCon'
     def __before__(self):
         super(PullrequestsController, self).__before__()
 
-    def _load_compare_data(self, pull_request, enable_comments=True):
+    def _load_compare_data(self, pull_request, inline_comments, enable_comments=True):
         """
         Load context data needed for generating compare diff
 
@@ -114,6 +119,7 b' class PullrequestsController(BaseRepoCon'
         except RepositoryRequirementError:
             c.missing_requirements = True
 
+        c.changes = {}
         c.missing_commits = False
         if (c.missing_requirements or
                 isinstance(source_commit, EmptyCommit) or
@@ -123,11 +129,31 b' class PullrequestsController(BaseRepoCon'
         else:
             vcs_diff = PullRequestModel().get_diff(pull_request)
             diff_processor = diffs.DiffProcessor(
-                vcs_diff, format='gitdiff', diff_limit=diff_limit,
+                vcs_diff, format='newdiff', diff_limit=diff_limit,
                 file_limit=file_limit, show_full_diff=c.fulldiff)
             _parsed = diff_processor.prepare()
 
-        c.limited_diff = isinstance(_parsed, LimitedDiffContainer)
+            commit_changes = OrderedDict()
+            _parsed = diff_processor.prepare()
+            c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
+
+            _parsed = diff_processor.prepare()
+
+            def _node_getter(commit):
+                def get_node(fname):
+                    try:
+                        return commit.get_node(fname)
+                    except NodeDoesNotExistError:
+                        return None
+                return get_node
+
+            c.diffset = codeblocks.DiffSet(
+                repo_name=c.repo_name,
+                source_node_getter=_node_getter(target_commit),
+                target_node_getter=_node_getter(source_commit),
+                comments=inline_comments
+            ).render_patchset(_parsed, target_commit.raw_id, source_commit.raw_id)
+
 
         c.files = []
         c.changes = {}
@@ -136,17 +162,17 b' class PullrequestsController(BaseRepoCon'
         c.included_files = []
         c.deleted_files = []
 
-        for f in _parsed:
-            st = f['stats']
-            c.lines_added += st['added']
-            c.lines_deleted += st['deleted']
+        # for f in _parsed:
+        #     st = f['stats']
+        #     c.lines_added += st['added']
+        #     c.lines_deleted += st['deleted']
 
-            fid = h.FID('', f['filename'])
-            c.files.append([fid, f['operation'], f['filename'], f['stats']])
-            c.included_files.append(f['filename'])
-            html_diff = diff_processor.as_html(enable_comments=enable_comments,
-                                               parsed_lines=[f])
-            c.changes[fid] = [f['operation'], f['filename'], html_diff, f]
+        #     fid = h.FID('', f['filename'])
+        #     c.files.append([fid, f['operation'], f['filename'], f['stats']])
+        #     c.included_files.append(f['filename'])
+        #     html_diff = diff_processor.as_html(enable_comments=enable_comments,
+        #                                        parsed_lines=[f])
+        #     c.changes[fid] = [f['operation'], f['filename'], html_diff, f]
 
     def _extract_ordering(self, request):
         column_index = safe_int(request.GET.get('order[0][column]'))
@@ -295,10 +321,12 b' class PullrequestsController(BaseRepoCon'
             redirect(url('pullrequest_home', repo_name=source_repo.repo_name))
 
         default_target_repo = source_repo
-        if (source_repo.parent and
-                not source_repo.parent.scm_instance().is_empty()):
-            # change default if we have a parent repo
-            default_target_repo = source_repo.parent
+
+        if source_repo.parent:
+            parent_vcs_obj = source_repo.parent.scm_instance()
+            if parent_vcs_obj and not parent_vcs_obj.is_empty():
+                # change default if we have a parent repo
+                default_target_repo = source_repo.parent
 
         target_repo_data = PullRequestModel().generate_repo_data(
             default_target_repo)
@@ -360,7 +388,8 b' class PullrequestsController(BaseRepoCon'
         add_parent = False
         if repo.parent:
             if filter_query in repo.parent.repo_name:
-                if not repo.parent.scm_instance().is_empty():
+                parent_vcs_obj = repo.parent.scm_instance()
+                if parent_vcs_obj and not parent_vcs_obj.is_empty():
                     add_parent = True
 
         limit = 20 - 1 if add_parent else 20
@@ -397,8 +426,10 b' class PullrequestsController(BaseRepoCon'
         if not repo:
             raise HTTPNotFound
 
+        controls = peppercorn.parse(request.POST.items())
+
         try:
-            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)
+            _form = PullRequestForm(repo.repo_id)().to_python(controls)
         except formencode.Invalid as errors:
             if errors.error_dict.get('revisions'):
                 msg = 'Revisions: %s' % errors.error_dict['revisions']
@@ -417,7 +448,8 b' class PullrequestsController(BaseRepoCon'
         target_repo = _form['target_repo']
         target_ref = _form['target_ref']
         commit_ids = _form['revisions'][::-1]
-        reviewers = _form['review_members']
+        reviewers = [
+            (r['user_id'], r['reasons']) for r in _form['review_members']]
 
         # find the ancestor for this pr
         source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
@@ -476,8 +508,11 b' class PullrequestsController(BaseRepoCon'
         allowed_to_update = PullRequestModel().check_user_update(
             pull_request, c.rhodecode_user)
         if allowed_to_update:
-            if 'reviewers_ids' in request.POST:
-                self._update_reviewers(pull_request_id)
+            controls = peppercorn.parse(request.POST.items())
+
+            if 'review_members' in controls:
+                self._update_reviewers(
+                    pull_request_id, controls['review_members'])
             elif str2bool(request.POST.get('update_commits', 'false')):
                 self._update_commits(pull_request)
             elif str2bool(request.POST.get('close_pull_request', 'false')):
@@ -506,32 +541,51 b' class PullrequestsController(BaseRepoCon'
         return
 
     def _update_commits(self, pull_request):
-        try:
-            if PullRequestModel().has_valid_update_type(pull_request):
-                updated_version, changes = PullRequestModel().update_commits(
-                    pull_request)
-                if updated_version:
-                    msg = _(
-                        u'Pull request updated to "{source_commit_id}" with '
-                        u'{count_added} added, {count_removed} removed '
-                        u'commits.'
-                    ).format(
-                        source_commit_id=pull_request.source_ref_parts.commit_id,
-                        count_added=len(changes.added),
-                        count_removed=len(changes.removed))
-                    h.flash(msg, category='success')
-                else:
-                    h.flash(_("Nothing changed in pull request."),
-                            category='warning')
-            else:
-                msg = _(
-                    u"Skipping update of pull request due to reference "
-                    u"type: {reference_type}"
-                ).format(reference_type=pull_request.source_ref_parts.type)
-                h.flash(msg, category='warning')
-        except CommitDoesNotExistError:
-            h.flash(
-                _(u'Update failed due to missing commits.'), category='error')
+        resp = PullRequestModel().update_commits(pull_request)
+
+        if resp.executed:
+            msg = _(
+                u'Pull request updated to "{source_commit_id}" with '
+                u'{count_added} added, {count_removed} removed commits.')
+            msg = msg.format(
+                source_commit_id=pull_request.source_ref_parts.commit_id,
+                count_added=len(resp.changes.added),
+                count_removed=len(resp.changes.removed))
+            h.flash(msg, category='success')
+
+            registry = get_current_registry()
+            rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
+            channelstream_config = rhodecode_plugins.get('channelstream', {})
+            if channelstream_config.get('enabled'):
+                message = msg + (
+                    ' - <a onclick="window.location.reload()">'
+                    '<strong>{}</strong></a>'.format(_('Reload page')))
+                channel = '/repo${}$/pr/{}'.format(
+                    pull_request.target_repo.repo_name,
+                    pull_request.pull_request_id
+                )
+                payload = {
+                    'type': 'message',
+                    'user': 'system',
+                    'exclude_users': [request.user.username],
+                    'channel': channel,
+                    'message': {
+                        'message': message,
+                        'level': 'success',
+                        'topic': '/notifications'
+                    }
+                }
+                channelstream_request(
+                    channelstream_config, [payload], '/message',
+                    raise_exc=False)
+        else:
+            msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
+            warning_reasons = [
+                UpdateFailureReason.NO_CHANGE,
+                UpdateFailureReason.WRONG_REF_TPYE,
+            ]
+            category = 'warning' if resp.reason in warning_reasons else 'error'
+            h.flash(msg, category=category)
 
     @auth.CSRFRequired()
     @LoginRequired()
@@ -601,11 +655,10 b' class PullrequestsController(BaseRepoCon'
                 merge_resp.failure_reason)
             h.flash(msg, category='error')
 
-    def _update_reviewers(self, pull_request_id):
-        reviewers_ids = map(int, filter(
-            lambda v: v not in [None, ''],
-            request.POST.get('reviewers_ids', '').split(',')))
-        PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)
+    def _update_reviewers(self, pull_request_id, review_members):
+        reviewers = [
+            (int(r['user_id']), r['reasons']) for r in review_members]
+        PullRequestModel().update_reviewers(pull_request_id, reviewers)
         Session().commit()
 
     def _reject_close(self, pull_request):
@@ -655,6 +708,10 b' class PullrequestsController(BaseRepoCon'
             c.pull_request, c.rhodecode_user) and not c.pull_request.is_closed()
         c.allowed_to_merge = PullRequestModel().check_user_merge(
             c.pull_request, c.rhodecode_user) and not c.pull_request.is_closed()
+        c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
+            c.pull_request)
+        c.allowed_to_delete = PullRequestModel().check_user_delete(
+            c.pull_request, c.rhodecode_user) and not c.pull_request.is_closed()
 
         cc_model = ChangesetCommentsModel()
 
@@ -669,23 +726,13 b' class PullrequestsController(BaseRepoCon'
             c.pr_merge_status = False
         # load compare data into template context
         enable_comments = not c.pull_request.is_closed()
-        self._load_compare_data(c.pull_request, enable_comments=enable_comments)
 
-        # this is a hack to properly display links, when creating PR, the
-        # compare view and others uses different notation, and
-        # compare_commits.html renders links based on the target_repo.
-        # We need to swap that here to generate it properly on the html side
-        c.target_repo = c.source_repo
 
         # inline comments
-        c.inline_cnt = 0
         c.inline_comments = cc_model.get_inline_comments(
             c.rhodecode_db_repo.repo_id,
-            pull_request=pull_request_id).items()
-        # count inline comments
-        for __, lines in c.inline_comments:
-            for comments in lines.values():
-                c.inline_cnt += len(comments)
+            pull_request=pull_request_id)
+        c.inline_cnt = len(c.inline_comments)
 
         # outdated comments
         c.outdated_cnt = 0
@@ -702,6 +749,15 b' class PullrequestsController(BaseRepoCon'
         else:
             c.outdated_comments = {}
 
+        self._load_compare_data(
+            c.pull_request, c.inline_comments, enable_comments=enable_comments)
+
+        # this is a hack to properly display links, when creating PR, the
+        # compare view and others uses different notation, and
+        # compare_commits.html renders links based on the target_repo.
+        # We need to swap that here to generate it properly on the html side
+        c.target_repo = c.source_repo
+
         # comments
         c.comments = cc_model.get_comments(c.rhodecode_db_repo.repo_id,
                                            pull_request=pull_request_id)

rhodecode/controllers/summary.py

@@ -251,6 +251,16 b' class SummaryController(BaseRepoControll'
         }
         return data
 
+    @LoginRequired()
+    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
+                                   'repository.admin')
+    @jsonify
+    def repo_default_reviewers_data(self, repo_name):
+        return {
+            'reviewers': [utils.reviewer_as_json(
+                user=c.rhodecode_db_repo.user, reasons=None)]
+        }
+
     @jsonify
     def repo_refs_changelog_data(self, repo_name):
         repo = c.rhodecode_repo

rhodecode/controllers/utils.py

@@ -86,3 +86,21 b' def get_commit_from_ref_name(repo, ref_n'
                     '%s "%s" does not exist' % (ref_type, ref_name))
 
     return repo_scm.get_commit(commit_id)
+
+
+def reviewer_as_json(user, reasons):
+    """
+    Returns json struct of a reviewer for frontend
+
+    :param user: the reviewer
+    :param reasons: list of strings of why they are reviewers
+    """
+
+    return {
+        'user_id': user.user_id,
+        'reasons': reasons,
+        'username': user.username,
+        'firstname': user.firstname,
+        'lastname': user.lastname,
+        'gravatar_link': h.gravatar_url(user.email, 14),
+    }

rhodecode/events/__init__.py

@@ -48,6 +48,7 b' from rhodecode.events.base import Rhodec'
 
 from rhodecode.events.user import (  # noqa
     UserPreCreate,
+    UserPostCreate,
     UserPreUpdate,
     UserRegistered
 )

rhodecode/events/user.py

@@ -51,6 +51,19 b' class UserPreCreate(RhodecodeEvent):'
         self.user_data = user_data
 
 
+@implementer(IUserPreCreate)
+class UserPostCreate(RhodecodeEvent):
+    """
+    An instance of this class is emitted as an :term:`event` after a new user
+    object is created.
+    """
+    name = 'user-post-create'
+    display_name = lazy_ugettext('user post create')
+
+    def __init__(self, user_data):
+        self.user_data = user_data
+
+
 @implementer(IUserPreUpdate)
 class UserPreUpdate(RhodecodeEvent):
     """

rhodecode/integrations/types/hipchat.py

@@ -161,7 +161,7 b' class HipchatIntegrationType(Integration'
         comment_text = data['comment']['text']
         if len(comment_text) > 200:
             comment_text = '{comment_text}<a href="{comment_url}">...<a/>'.format(
-                comment_text=comment_text[:200],
+                comment_text=h.html_escape(comment_text[:200]),
                 comment_url=data['comment']['url'],
             )
 
@@ -179,8 +179,8 b' class HipchatIntegrationType(Integration'
                 number=data['pullrequest']['pull_request_id'],
                 pr_url=data['pullrequest']['url'],
                 pr_status=data['pullrequest']['status'],
-                pr_title=data['pullrequest']['title'],
-                comment_text=comment_text
+                pr_title=h.html_escape(data['pullrequest']['title']),
+                comment_text=h.html_escape(comment_text)
             )
         )
 
@@ -193,7 +193,7 b' class HipchatIntegrationType(Integration'
                 number=data['pullrequest']['pull_request_id'],
                 pr_url=data['pullrequest']['url'],
                 pr_status=data['pullrequest']['status'],
-                pr_title=data['pullrequest']['title'],
+                pr_title=h.html_escape(data['pullrequest']['title']),
             )
         )
 
@@ -206,21 +206,20 b' class HipchatIntegrationType(Integration'
         }.get(event.__class__, str(event.__class__))
 
         return ('Pull request <a href="{url}">#{number}</a> - {title} '
-                '{action} by {user}').format(
+                '{action} by <b>{user}</b>').format(
             user=data['actor']['username'],
             number=data['pullrequest']['pull_request_id'],
             url=data['pullrequest']['url'],
-            title=data['pullrequest']['title'],
+            title=h.html_escape(data['pullrequest']['title']),
             action=action
         )
 
     def format_repo_push_event(self, data):
         branch_data = {branch['name']: branch
-                      for branch in data['push']['branches']}
+                       for branch in data['push']['branches']}
 
         branches_commits = {}
         for commit in data['push']['commits']:
-            log.critical(commit)
             if commit['branch'] not in branches_commits:
                 branch_commits = {'branch': branch_data[commit['branch']],
                                   'commits': []}
@@ -238,7 +237,7 b' class HipchatIntegrationType(Integration'
     def format_repo_create_event(self, data):
         return '<a href="{}">{}</a> ({}) repository created by <b>{}</b>'.format(
             data['repo']['url'],
-            data['repo']['repo_name'],
+            h.html_escape(data['repo']['repo_name']),
             data['repo']['repo_type'],
             data['actor']['username'],
         )

rhodecode/integrations/types/slack.py

@@ -173,7 +173,7 b' class SlackIntegrationType(IntegrationTy'
 
         return (textwrap.dedent(
             '''
-            {user} commented on pull request <{pr_url}|#{number}> - {pr_title}:
+            *{user}* commented on pull request <{pr_url}|#{number}> - {pr_title}:
             >>> {comment_status}{comment_text}
             ''').format(
                 comment_status=comment_status,
@@ -208,7 +208,7 b' class SlackIntegrationType(IntegrationTy'
         }.get(event.__class__, str(event.__class__))
 
         return ('Pull request <{url}|#{number}> - {title} '
-                '{action} by {user}').format(
+                '`{action}` by *{user}*').format(
             user=data['actor']['username'],
             number=data['pullrequest']['pull_request_id'],
             url=data['pullrequest']['url'],
@@ -218,11 +218,10 b' class SlackIntegrationType(IntegrationTy'
 
     def format_repo_push_event(self, data):
         branch_data = {branch['name']: branch
-                      for branch in data['push']['branches']}
+                       for branch in data['push']['branches']}
 
         branches_commits = {}
         for commit in data['push']['commits']:
-            log.critical(commit)
             if commit['branch'] not in branches_commits:
                 branch_commits = {'branch': branch_data[commit['branch']],
                                   'commits': []}

rhodecode/integrations/types/webhook.py

@@ -19,13 +19,15 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from __future__ import unicode_literals
+import string
+from collections import OrderedDict
 
 import deform
 import logging
 import requests
 import colander
 from celery.task import task
-from mako.template import Template
+from requests.packages.urllib3.util.retry import Retry
 
 from rhodecode import events
 from rhodecode.translation import _
@@ -33,12 +35,127 b' from rhodecode.integrations.types.base i'
 
 log = logging.getLogger(__name__)
 
+# updating this required to update the `base_vars` passed in url calling func
+WEBHOOK_URL_VARS = [
+    'repo_name',
+    'repo_type',
+    'repo_id',
+    'repo_url',
+
+    # special attrs below that we handle, using multi-call
+    'branch',
+    'commit_id',
+
+    # pr events vars
+    'pull_request_id',
+    'pull_request_url',
+
+]
+URL_VARS = ', '.join('${' + x + '}' for x in WEBHOOK_URL_VARS)
+
+
+class WebhookHandler(object):
+    def __init__(self, template_url, secret_token):
+        self.template_url = template_url
+        self.secret_token = secret_token
+
+    def get_base_parsed_template(self, data):
+        """
+        initially parses the passed in template with some common variables
+        available on ALL calls
+        """
+        # note: make sure to update the `WEBHOOK_URL_VARS` if this changes
+        common_vars = {
+            'repo_name': data['repo']['repo_name'],
+            'repo_type': data['repo']['repo_type'],
+            'repo_id': data['repo']['repo_id'],
+            'repo_url': data['repo']['url'],
+        }
+
+        return string.Template(
+            self.template_url).safe_substitute(**common_vars)
+
+    def repo_push_event_handler(self, event, data):
+        url = self.get_base_parsed_template(data)
+        url_cals = []
+        branch_data = OrderedDict()
+        for obj in data['push']['branches']:
+            branch_data[obj['name']] = obj
+
+        branches_commits = OrderedDict()
+        for commit in data['push']['commits']:
+            if commit['branch'] not in branches_commits:
+                branch_commits = {'branch': branch_data[commit['branch']],
+                                  'commits': []}
+                branches_commits[commit['branch']] = branch_commits
+
+            branch_commits = branches_commits[commit['branch']]
+            branch_commits['commits'].append(commit)
+
+        if '${branch}' in url:
+            # call it multiple times, for each branch if used in variables
+            for branch, commit_ids in branches_commits.items():
+                branch_url = string.Template(url).safe_substitute(branch=branch)
+                # call further down for each commit if used
+                if '${commit_id}' in branch_url:
+                    for commit_data in commit_ids['commits']:
+                        commit_id = commit_data['raw_id']
+                        commit_url = string.Template(branch_url).safe_substitute(
+                            commit_id=commit_id)
+                        # register per-commit call
+                        log.debug(
+                            'register webhook call(%s) to url %s', event, commit_url)
+                        url_cals.append((commit_url, self.secret_token, data))
+
+                else:
+                    # register per-branch call
+                    log.debug(
+                        'register webhook call(%s) to url %s', event, branch_url)
+                    url_cals.append((branch_url, self.secret_token, data))
+
+        else:
+            log.debug(
+                'register webhook call(%s) to url %s', event, url)
+            url_cals.append((url, self.secret_token, data))
+
+        return url_cals
+
+    def repo_create_event_handler(self, event, data):
+        url = self.get_base_parsed_template(data)
+        log.debug(
+            'register webhook call(%s) to url %s', event, url)
+        return [(url, self.secret_token, data)]
+
+    def pull_request_event_handler(self, event, data):
+        url = self.get_base_parsed_template(data)
+        log.debug(
+            'register webhook call(%s) to url %s', event, url)
+        url = string.Template(url).safe_substitute(
+            pull_request_id=data['pullrequest']['pull_request_id'],
+            pull_request_url=data['pullrequest']['url'])
+        return [(url, self.secret_token, data)]
+
+    def __call__(self, event, data):
+        if isinstance(event, events.RepoPushEvent):
+            return self.repo_push_event_handler(event, data)
+        elif isinstance(event, events.RepoCreateEvent):
+            return self.repo_create_event_handler(event, data)
+        elif isinstance(event, events.PullRequestEvent):
+            return self.pull_request_event_handler(event, data)
+        else:
+            raise ValueError('event type not supported: %s' % events)
+
 
 class WebhookSettingsSchema(colander.Schema):
     url = colander.SchemaNode(
         colander.String(),
         title=_('Webhook URL'),
-        description=_('URL of the webhook to receive POST event.'),
+        description=
+            _('URL of the webhook to receive POST event. Following variables '
+              'are allowed to be used: {vars}. Some of the variables would '
+              'trigger multiple calls, like ${{branch}} or ${{commit_id}}. '
+              'Webhook will be called as many times as unique objects in '
+              'data in such cases.').format(vars=URL_VARS),
         missing=colander.required,
         required=True,
         validator=colander.url,
@@ -58,8 +175,6 b' class WebhookSettingsSchema(colander.Sch'
     )
 
 
-
-
 class WebhookIntegrationType(IntegrationTypeBase):
     key = 'webhook'
     display_name = _('Webhook')
@@ -104,14 +219,30 b' class WebhookIntegrationType(Integration'
             return
 
         data = event.as_dict()
-        post_to_webhook(data, self.settings)
+        template_url = self.settings['url']
+
+        handler = WebhookHandler(template_url, self.settings['secret_token'])
+        url_calls = handler(event, data)
+        log.debug('webhook: calling following urls: %s',
+                  [x[0] for x in url_calls])
+        post_to_webhook(url_calls)
 
 
 @task(ignore_result=True)
-def post_to_webhook(data, settings):
-    log.debug('sending event:%s to webhook %s', data['name'], settings['url'])
-    resp = requests.post(settings['url'], json={
-        'token': settings['secret_token'],
-        'event': data
-    })
-    resp.raise_for_status()  # raise exception on a failed request
+def post_to_webhook(url_calls):
+    max_retries = 3
+    for url, token, data in url_calls:
+        # retry max N times
+        retries = Retry(
+            total=max_retries,
+            backoff_factor=0.15,
+            status_forcelist=[500, 502, 503, 504])
+        req_session = requests.Session()
+        req_session.mount(
+            'http://', requests.adapters.HTTPAdapter(max_retries=retries))
+
+        resp = req_session.post(url, json={
+            'token': token,
+            'event': data
+        })
+        resp.raise_for_status()  # raise exception on a failed request

rhodecode/lib/auth.py

@@ -49,7 +49,7 b' from rhodecode.model.meta import Session'
 from rhodecode.model.user import UserModel
 from rhodecode.model.db import (
     User, Repository, Permission, UserToPerm, UserGroupToPerm, UserGroupMember,
-    UserIpMap, UserApiKeys)
+    UserIpMap, UserApiKeys, RepoGroup)
 from rhodecode.lib import caches
 from rhodecode.lib.utils2 import safe_unicode, aslist, safe_str, md5
 from rhodecode.lib.utils import (
@@ -983,6 +983,9 b' class AuthUser(object):'
         inherit = self.inherit_default_permissions
         return AuthUser.check_ip_allowed(self.user_id, self.ip_addr,
                                          inherit_from_default=inherit)
+    @property
+    def personal_repo_group(self):
+        return RepoGroup.get_user_personal_repo_group(self.user_id)
 
     @classmethod
     def check_ip_allowed(cls, user_id, ip_addr, inherit_from_default):

rhodecode/lib/base.py

@@ -163,7 +163,8 b' def get_access_path(environ):'
 
 
 def vcs_operation_context(
-        environ, repo_name, username, action, scm, check_locking=True):
+        environ, repo_name, username, action, scm, check_locking=True,
+        is_shadow_repo=False):
     """
     Generate the context for a vcs operation, e.g. push or pull.
 
@@ -200,6 +201,7 b' def vcs_operation_context('
         'locked_by': locked_by,
         'server_url': utils2.get_server_url(environ),
         'hooks': get_enabled_hook_classes(ui_settings),
+        'is_shadow_repo': is_shadow_repo,
     }
     return extras
 
@@ -363,6 +365,18 b' def attach_context_attributes(context, r'
     # Fix this and remove it from base controller.
     # context.repo_name = get_repo_slug(request)  # can be empty
 
+    diffmode = 'sideside'
+    if request.GET.get('diffmode'):
+        if request.GET['diffmode'] == 'unified':
+            diffmode = 'unified'
+    elif request.session.get('diffmode'):
+        diffmode = request.session['diffmode']
+
+    context.diffmode = diffmode
+
+    if request.session.get('diffmode') != diffmode:
+        request.session['diffmode'] = diffmode
+
     context.csrf_token = auth.get_csrf_token()
     context.backends = rhodecode.BACKENDS.keys()
     context.backends.sort()

rhodecode/lib/caches.py

@@ -24,9 +24,10 b' import logging'
 import threading
 
 from beaker.cache import _cache_decorate, cache_regions, region_invalidate
+from sqlalchemy.exc import IntegrityError
 
 from rhodecode.lib.utils import safe_str, md5
-from rhodecode.model.db import Session, CacheKey, IntegrityError
+from rhodecode.model.db import Session, CacheKey
 
 log = logging.getLogger(__name__)
 

rhodecode/lib/channelstream.py

@@ -18,16 +18,14 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import hashlib
+import itsdangerous
 import logging
 import os
-
-import itsdangerous
 import requests
-
 from dogpile.core import ReadWriteMutex
 
 import rhodecode.lib.helpers as h
-
 from rhodecode.lib.auth import HasRepoPermissionAny
 from rhodecode.lib.ext_json import json
 from rhodecode.model.db import User
@@ -81,7 +79,7 b' def get_user_data(user_id):'
         'username': user.username,
         'first_name': user.name,
         'last_name': user.lastname,
-        'icon_link': h.gravatar_url(user.email, 14),
+        'icon_link': h.gravatar_url(user.email, 60),
         'display_name': h.person(user, 'username_or_name_or_email'),
         'display_link': h.link_to_user(user),
         'notifications': user.user_data.get('notification_status', True)
@@ -169,7 +167,9 b' def parse_channels_info(info_result, inc'
 
 
 def log_filepath(history_location, channel_name):
-    filename = '{}.log'.format(channel_name.encode('hex'))
+    hasher = hashlib.sha256()
+    hasher.update(channel_name.encode('utf8'))
+    filename = '{}.log'.format(hasher.hexdigest())
     filepath = os.path.join(history_location, filename)
     return filepath
 

rhodecode/lib/diffs.py

@@ -180,6 +180,8 b' class Action(object):'
     UNMODIFIED = 'unmod'
 
     CONTEXT = 'context'
+    OLD_NO_NL = 'old-no-nl'
+    NEW_NO_NL = 'new-no-nl'
 
 
 class DiffProcessor(object):
@@ -227,7 +229,7 b' class DiffProcessor(object):'
             self._parser = self._parse_gitdiff
         else:
             self.differ = self._highlight_line_udiff
-            self._parser = self._parse_udiff
+            self._parser = self._new_parse_gitdiff
 
     def _copy_iterator(self):
         """
@@ -491,9 +493,181 b' class DiffProcessor(object):'
 
         return diff_container(sorted(_files, key=sorter))
 
-    def _parse_udiff(self, inline_diff=True):
-        raise NotImplementedError()
+
+    # FIXME: NEWDIFFS: dan: this replaces the old _escaper function
+    def _process_line(self, string):
+        """
+        Process a diff line, checks the diff limit
+
+        :param string:
+        """
+
+        self.cur_diff_size += len(string)
+
+        if not self.show_full_diff and (self.cur_diff_size > self.diff_limit):
+            raise DiffLimitExceeded('Diff Limit Exceeded')
+
+        return safe_unicode(string)
+
+    # FIXME: NEWDIFFS: dan: this replaces _parse_gitdiff
+    def _new_parse_gitdiff(self, inline_diff=True):
+        _files = []
+        diff_container = lambda arg: arg
+        for chunk in self._diff.chunks():
+            head = chunk.header
+            log.debug('parsing diff %r' % head)
+
+            diff = imap(self._process_line, chunk.diff.splitlines(1))
+            raw_diff = chunk.raw
+            limited_diff = False
+            exceeds_limit = False
+            # if 'empty_file_to_modify_and_rename' in head['a_path']:
+            #     1/0
+            op = None
+            stats = {
+                'added': 0,
+                'deleted': 0,
+                'binary': False,
+                'old_mode': None,
+                'new_mode': None,
+                'ops': {},
+            }
+            if head['old_mode']:
+                stats['old_mode'] = head['old_mode']
+            if head['new_mode']:
+                stats['new_mode'] = head['new_mode']
+            if head['b_mode']:
+                stats['new_mode'] = head['b_mode']
+
+            if head['deleted_file_mode']:
+                op = OPS.DEL
+                stats['binary'] = True
+                stats['ops'][DEL_FILENODE] = 'deleted file'
+
+            elif head['new_file_mode']:
+                op = OPS.ADD
+                stats['binary'] = True
+                stats['old_mode'] = None
+                stats['new_mode'] = head['new_file_mode']
+                stats['ops'][NEW_FILENODE] = 'new file %s' % head['new_file_mode']
+            else:  # modify operation, can be copy, rename or chmod
+
+                # CHMOD
+                if head['new_mode'] and head['old_mode']:
+                    op = OPS.MOD
+                    stats['binary'] = True
+                    stats['ops'][CHMOD_FILENODE] = (
+                        'modified file chmod %s => %s' % (
+                            head['old_mode'], head['new_mode']))
+
+                # RENAME
+                if head['rename_from'] != head['rename_to']:
+                    op = OPS.MOD
+                    stats['binary'] = True
+                    stats['renamed'] = (head['rename_from'], head['rename_to'])
+                    stats['ops'][RENAMED_FILENODE] = (
+                        'file renamed from %s to %s' % (
+                            head['rename_from'], head['rename_to']))
+                # COPY
+                if head.get('copy_from') and head.get('copy_to'):
+                    op = OPS.MOD
+                    stats['binary'] = True
+                    stats['copied'] = (head['copy_from'], head['copy_to'])
+                    stats['ops'][COPIED_FILENODE] = (
+                        'file copied from %s to %s' % (
+                            head['copy_from'], head['copy_to']))
 
+                # If our new parsed headers didn't match anything fallback to
+                # old style detection
+                if op is None:
+                    if not head['a_file'] and head['b_file']:
+                        op = OPS.ADD
+                        stats['binary'] = True
+                        stats['new_file'] = True
+                        stats['ops'][NEW_FILENODE] = 'new file'
+
+                    elif head['a_file'] and not head['b_file']:
+                        op = OPS.DEL
+                        stats['binary'] = True
+                        stats['ops'][DEL_FILENODE] = 'deleted file'
+
+                # it's not ADD not DELETE
+                if op is None:
+                    op = OPS.MOD
+                    stats['binary'] = True
+                    stats['ops'][MOD_FILENODE] = 'modified file'
+
+            # a real non-binary diff
+            if head['a_file'] or head['b_file']:
+                try:
+                    raw_diff, chunks, _stats = self._new_parse_lines(diff)
+                    stats['binary'] = False
+                    stats['added'] = _stats[0]
+                    stats['deleted'] = _stats[1]
+                    # explicit mark that it's a modified file
+                    if op == OPS.MOD:
+                        stats['ops'][MOD_FILENODE] = 'modified file'
+                    exceeds_limit = len(raw_diff) > self.file_limit
+
+                    # changed from _escaper function so we validate size of
+                    # each file instead of the whole diff
+                    # diff will hide big files but still show small ones
+                    # from my tests, big files are fairly safe to be parsed
+                    # but the browser is the bottleneck
+                    if not self.show_full_diff and exceeds_limit:
+                        raise DiffLimitExceeded('File Limit Exceeded')
+
+                except DiffLimitExceeded:
+                    diff_container = lambda _diff: \
+                        LimitedDiffContainer(
+                            self.diff_limit, self.cur_diff_size, _diff)
+
+                    exceeds_limit = len(raw_diff) > self.file_limit
+                    limited_diff = True
+                    chunks = []
+
+            else:  # GIT format binary patch, or possibly empty diff
+                if head['bin_patch']:
+                    # we have operation already extracted, but we mark simply
+                    # it's a diff we wont show for binary files
+                    stats['ops'][BIN_FILENODE] = 'binary diff hidden'
+                chunks = []
+
+            if chunks and not self.show_full_diff and op == OPS.DEL:
+                # if not full diff mode show deleted file contents
+                # TODO: anderson: if the view is not too big, there is no way
+                # to see the content of the file
+                chunks = []
+
+            chunks.insert(0, [{
+                                  'old_lineno': '',
+                                  'new_lineno': '',
+                                  'action': Action.CONTEXT,
+                                  'line': msg,
+                              } for _op, msg in stats['ops'].iteritems()
+                              if _op not in [MOD_FILENODE]])
+
+            original_filename = safe_unicode(head['a_path'])
+            _files.append({
+                'original_filename': original_filename,
+                'filename': safe_unicode(head['b_path']),
+                'old_revision': head['a_blob_id'],
+                'new_revision': head['b_blob_id'],
+                'chunks': chunks,
+                'raw_diff': safe_unicode(raw_diff),
+                'operation': op,
+                'stats': stats,
+                'exceeds_limit': exceeds_limit,
+                'is_limited_diff': limited_diff,
+            })
+
+
+        sorter = lambda info: {OPS.ADD: 0, OPS.MOD: 1,
+                               OPS.DEL: 2}.get(info['operation'])
+
+        return diff_container(sorted(_files, key=sorter))
+
+    # FIXME: NEWDIFFS: dan: this gets replaced by _new_parse_lines
     def _parse_lines(self, diff):
         """
         Parse the diff an return data for the template.
@@ -588,6 +762,107 b' class DiffProcessor(object):'
             pass
         return ''.join(raw_diff), chunks, stats
 
+    # FIXME: NEWDIFFS: dan: this replaces _parse_lines
+    def _new_parse_lines(self, diff):
+        """
+        Parse the diff an return data for the template.
+        """
+
+        lineiter = iter(diff)
+        stats = [0, 0]
+        chunks = []
+        raw_diff = []
+
+        try:
+            line = lineiter.next()
+
+            while line:
+                raw_diff.append(line)
+                match = self._chunk_re.match(line)
+
+                if not match:
+                    break
+
+                gr = match.groups()
+                (old_line, old_end,
+                 new_line, new_end) = [int(x or 1) for x in gr[:-1]]
+
+                lines = []
+                hunk = {
+                    'section_header': gr[-1],
+                    'source_start': old_line,
+                    'source_length': old_end,
+                    'target_start': new_line,
+                    'target_length': new_end,
+                    'lines': lines,
+                }
+                chunks.append(hunk)
+
+                old_line -= 1
+                new_line -= 1
+
+                context = len(gr) == 5
+                old_end += old_line
+                new_end += new_line
+
+                line = lineiter.next()
+
+                while old_line < old_end or new_line < new_end:
+                    command = ' '
+                    if line:
+                        command = line[0]
+
+                    affects_old = affects_new = False
+
+                    # ignore those if we don't expect them
+                    if command in '#@':
+                        continue
+                    elif command == '+':
+                        affects_new = True
+                        action = Action.ADD
+                        stats[0] += 1
+                    elif command == '-':
+                        affects_old = True
+                        action = Action.DELETE
+                        stats[1] += 1
+                    else:
+                        affects_old = affects_new = True
+                        action = Action.UNMODIFIED
+
+                    if not self._newline_marker.match(line):
+                        old_line += affects_old
+                        new_line += affects_new
+                        lines.append({
+                            'old_lineno':   affects_old and old_line or '',
+                            'new_lineno':   affects_new and new_line or '',
+                            'action':       action,
+                            'line':         self._clean_line(line, command)
+                        })
+                        raw_diff.append(line)
+
+                    line = lineiter.next()
+
+                    if self._newline_marker.match(line):
+                        # we need to append to lines, since this is not
+                        # counted in the line specs of diff
+                        if affects_old:
+                            action = Action.OLD_NO_NL
+                        elif affects_new:
+                            action = Action.NEW_NO_NL
+                        else:
+                            raise Exception('invalid context for no newline')
+
+                        lines.append({
+                            'old_lineno':   None,
+                            'new_lineno':   None,
+                            'action':       action,
+                            'line':         self._clean_line(line, command)
+                        })
+
+        except StopIteration:
+            pass
+        return ''.join(raw_diff), chunks, stats
+
     def _safe_id(self, idstring):
         """Make a string safe for including in an id attribute.
 
@@ -699,7 +974,7 b' class DiffProcessor(object):'
                     if enable_comments and change['action'] != Action.CONTEXT:
                         _html.append('''<a href="#"><span class="icon-comment-add"></span></a>''')
 
-                    _html.append('''</span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>\n''')
+                    _html.append('''</span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>\n''')
 
                     ###########################################################
                     # OLD LINE NUMBER

rhodecode/lib/helpers.py

@@ -67,7 +67,6 b' from webhelpers.html.tags import _set_in'
     convert_boolean_attrs, NotGiven, _make_safe_id_component
 from webhelpers2.number import format_byte_size
 
-from rhodecode.lib.annotate import annotate_highlight
 from rhodecode.lib.action_parser import action_parser
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
@@ -108,6 +107,15 b' def pylons_url_current(*args, **kw):'
 url.current = pylons_url_current
 
 
+def url_replace(**qargs):
+    """ Returns the current request url while replacing query string args """
+
+    request = get_current_request()
+    new_args = request.GET.mixed()
+    new_args.update(qargs)
+    return url('', **new_args)
+
+
 def asset(path, ver=None):
     """
     Helper to generate a static asset file path for rhodecode assets
@@ -125,17 +133,18 b' def asset(path, ver=None):'
         'rhodecode:public/{}'.format(path), _query=query)
 
 
-def html_escape(text, html_escape_table=None):
+default_html_escape_table = {
+    ord('&'): u'&',
+    ord('<'): u'&lt;',
+    ord('>'): u'&gt;',
+    ord('"'): u'&quot;',
+    ord("'"): u'&#39;',
+}
+
+
+def html_escape(text, html_escape_table=default_html_escape_table):
     """Produce entities within text."""
-    if not html_escape_table:
-        html_escape_table = {
-            "&": "&amp;",
-            '"': "&quot;",
-            "'": "&apos;",
-            ">": "&gt;",
-            "<": "&lt;",
-        }
-    return "".join(html_escape_table.get(c, c) for c in text)
+    return text.translate(html_escape_table)
 
 
 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
@@ -500,6 +509,86 b' def get_matching_line_offsets(lines, ter'
     return matching_lines
 
 
+def hsv_to_rgb(h, s, v):
+    """ Convert hsv color values to rgb """
+
+    if s == 0.0:
+        return v, v, v
+    i = int(h * 6.0)  # XXX assume int() truncates!
+    f = (h * 6.0) - i
+    p = v * (1.0 - s)
+    q = v * (1.0 - s * f)
+    t = v * (1.0 - s * (1.0 - f))
+    i = i % 6
+    if i == 0:
+        return v, t, p
+    if i == 1:
+        return q, v, p
+    if i == 2:
+        return p, v, t
+    if i == 3:
+        return p, q, v
+    if i == 4:
+        return t, p, v
+    if i == 5:
+        return v, p, q
+
+
+def unique_color_generator(n=10000, saturation=0.10, lightness=0.95):
+    """
+    Generator for getting n of evenly distributed colors using
+    hsv color and golden ratio. It always return same order of colors
+
+    :param n: number of colors to generate
+    :param saturation: saturation of returned colors
+    :param lightness: lightness of returned colors
+    :returns: RGB tuple
+    """
+
+    golden_ratio = 0.618033988749895
+    h = 0.22717784590367374
+
+    for _ in xrange(n):
+        h += golden_ratio
+        h %= 1
+        HSV_tuple = [h, saturation, lightness]
+        RGB_tuple = hsv_to_rgb(*HSV_tuple)
+        yield map(lambda x: str(int(x * 256)), RGB_tuple)
+
+
+def color_hasher(n=10000, saturation=0.10, lightness=0.95):
+    """
+    Returns a function which when called with an argument returns a unique
+    color for that argument, eg.
+
+    :param n: number of colors to generate
+    :param saturation: saturation of returned colors
+    :param lightness: lightness of returned colors
+    :returns: css RGB string
+
+    >>> color_hash = color_hasher()
+    >>> color_hash('hello')
+    'rgb(34, 12, 59)'
+    >>> color_hash('hello')
+    'rgb(34, 12, 59)'
+    >>> color_hash('other')
+    'rgb(90, 224, 159)'
+    """
+
+    color_dict = {}
+    cgenerator = unique_color_generator(
+        saturation=saturation, lightness=lightness)
+
+    def get_color_string(thing):
+        if thing in color_dict:
+            col = color_dict[thing]
+        else:
+            col = color_dict[thing] = cgenerator.next()
+        return "rgb(%s)" % (', '.join(col))
+
+    return get_color_string
+
+
 def get_lexer_safe(mimetype=None, filepath=None):
     """
     Tries to return a relevant pygments lexer using mimetype/filepath name,
@@ -536,92 +625,6 b' def pygmentize(filenode, **kwargs):'
                                   CodeHtmlFormatter(**kwargs)))
 
 
-def pygmentize_annotation(repo_name, filenode, **kwargs):
-    """
-    pygmentize function for annotation
-
-    :param filenode:
-    """
-
-    color_dict = {}
-
-    def gen_color(n=10000):
-        """generator for getting n of evenly distributed colors using
-        hsv color and golden ratio. It always return same order of colors
-
-        :returns: RGB tuple
-        """
-
-        def hsv_to_rgb(h, s, v):
-            if s == 0.0:
-                return v, v, v
-            i = int(h * 6.0)  # XXX assume int() truncates!
-            f = (h * 6.0) - i
-            p = v * (1.0 - s)
-            q = v * (1.0 - s * f)
-            t = v * (1.0 - s * (1.0 - f))
-            i = i % 6
-            if i == 0:
-                return v, t, p
-            if i == 1:
-                return q, v, p
-            if i == 2:
-                return p, v, t
-            if i == 3:
-                return p, q, v
-            if i == 4:
-                return t, p, v
-            if i == 5:
-                return v, p, q
-
-        golden_ratio = 0.618033988749895
-        h = 0.22717784590367374
-
-        for _ in xrange(n):
-            h += golden_ratio
-            h %= 1
-            HSV_tuple = [h, 0.95, 0.95]
-            RGB_tuple = hsv_to_rgb(*HSV_tuple)
-            yield map(lambda x: str(int(x * 256)), RGB_tuple)
-
-    cgenerator = gen_color()
-
-    def get_color_string(commit_id):
-        if commit_id in color_dict:
-            col = color_dict[commit_id]
-        else:
-            col = color_dict[commit_id] = cgenerator.next()
-        return "color: rgb(%s)! important;" % (', '.join(col))
-
-    def url_func(repo_name):
-
-        def _url_func(commit):
-            author = commit.author
-            date = commit.date
-            message = tooltip(commit.message)
-
-            tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"
-                            " %s<br/><b>Date:</b> %s</b><br/><b>Message:"
-                            "</b> %s<br/></div>")
-
-            tooltip_html = tooltip_html % (author, date, message)
-            lnk_format = '%5s:%s' % ('r%s' % commit.idx, commit.short_id)
-            uri = link_to(
-                lnk_format,
-                url('changeset_home', repo_name=repo_name,
-                    revision=commit.raw_id),
-                style=get_color_string(commit.raw_id),
-                class_='tooltip',
-                title=tooltip_html
-            )
-
-            uri += '\n'
-            return uri
-        return _url_func
-
-    return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))
-
-
 def is_following_repo(repo_name, user_id):
     from rhodecode.model.scm import ScmModel
     return ScmModel().is_following_repo(repo_name, user_id)
@@ -678,6 +681,29 b' class Flash(_Flash):'
         session.save()
         return messages
 
+    def json_alerts(self):
+        payloads = []
+        messages = flash.pop_messages()
+        if messages:
+            for message in messages:
+                subdata = {}
+                if hasattr(message.message, 'rsplit'):
+                    flash_data = message.message.rsplit('|DELIM|', 1)
+                    org_message = flash_data[0]
+                    if len(flash_data) > 1:
+                        subdata = json.loads(flash_data[1])
+                else:
+                    org_message = message.message
+                payloads.append({
+                    'message': {
+                        'message': u'{}'.format(org_message),
+                        'level': message.category,
+                        'force': True,
+                        'subdata': subdata
+                    }
+                })
+        return json.dumps(payloads)
+
 flash = Flash()
 
 #==============================================================================

rhodecode/lib/hooks_base.py

@@ -38,6 +38,13 b' from rhodecode.model.db import Repositor'
 HookResponse = collections.namedtuple('HookResponse', ('status', 'output'))
 
 
+def is_shadow_repo(extras):
+    """
+    Returns ``True`` if this is an action executed against a shadow repository.
+    """
+    return extras['is_shadow_repo']
+
+
 def _get_scm_size(alias, root_path):
 
     if not alias.startswith('.'):
@@ -85,7 +92,6 b' def pre_push(extras):'
     """
     usr = User.get_by_username(extras.username)
 
-
     output = ''
     if extras.locked_by[0] and usr.user_id != int(extras.locked_by[0]):
         locked_by = User.get(extras.locked_by[0]).username
@@ -100,11 +106,12 b' def pre_push(extras):'
         else:
             raise _http_ret
 
-    # Calling hooks after checking the lock, for consistent behavior
-    pre_push_extension(repo_store_path=Repository.base_path(), **extras)
-
-    events.trigger(events.RepoPrePushEvent(repo_name=extras.repository,
-                                           extras=extras))
+    # Propagate to external components. This is done after checking the
+    # lock, for consistent behavior.
+    if not is_shadow_repo(extras):
+        pre_push_extension(repo_store_path=Repository.base_path(), **extras)
+        events.trigger(events.RepoPrePushEvent(
+            repo_name=extras.repository, extras=extras))
 
     return HookResponse(0, output)
 
@@ -130,10 +137,12 b' def pre_pull(extras):'
         else:
             raise _http_ret
 
-    # Calling hooks after checking the lock, for consistent behavior
-    pre_pull_extension(**extras)
-    events.trigger(events.RepoPrePullEvent(repo_name=extras.repository,
-                                           extras=extras))
+    # Propagate to external components. This is done after checking the
+    # lock, for consistent behavior.
+    if not is_shadow_repo(extras):
+        pre_pull_extension(**extras)
+        events.trigger(events.RepoPrePullEvent(
+            repo_name=extras.repository, extras=extras))
 
     return HookResponse(0, output)
 
@@ -144,14 +153,15 b' def post_pull(extras):'
     action = 'pull'
     action_logger(user, action, extras.repository, extras.ip, commit=True)
 
-    events.trigger(events.RepoPullEvent(repo_name=extras.repository,
-                                        extras=extras))
-    # extension hook call
-    post_pull_extension(**extras)
+    # Propagate to external components.
+    if not is_shadow_repo(extras):
+        post_pull_extension(**extras)
+        events.trigger(events.RepoPullEvent(
+            repo_name=extras.repository, extras=extras))
 
     output = ''
     # make lock is a tri state False, True, None. We only make lock on True
-    if extras.make_lock is True:
+    if extras.make_lock is True and not is_shadow_repo(extras):
         Repository.lock(Repository.get_by_repo_name(extras.repository),
                         user.user_id,
                         lock_reason=Repository.LOCK_PULL)
@@ -179,19 +189,20 b' def post_push(extras):'
     action_logger(
         extras.username, action, extras.repository, extras.ip, commit=True)
 
-    events.trigger(events.RepoPushEvent(repo_name=extras.repository,
-                                        pushed_commit_ids=commit_ids,
-                                        extras=extras))
-
-    # extension hook call
-    post_push_extension(
-        repo_store_path=Repository.base_path(),
-        pushed_revs=commit_ids,
-        **extras)
+    # Propagate to external components.
+    if not is_shadow_repo(extras):
+        post_push_extension(
+            repo_store_path=Repository.base_path(),
+            pushed_revs=commit_ids,
+            **extras)
+        events.trigger(events.RepoPushEvent(
+            repo_name=extras.repository,
+            pushed_commit_ids=commit_ids,
+            extras=extras))
 
     output = ''
     # make lock is a tri state False, True, None. We only release lock on False
-    if extras.make_lock is False:
+    if extras.make_lock is False and not is_shadow_repo(extras):
         Repository.unlock(Repository.get_by_repo_name(extras.repository))
         msg = 'Released lock on repo `%s`\n' % extras.repository
         output += msg

rhodecode/lib/hooks_daemon.py

@@ -195,9 +195,8 b' class HttpHooksCallbackDaemon(ThreadedHo'
         self._callback_thread = None
 
 
-def prepare_callback_daemon(extras, protocol=None, use_direct_calls=False):
+def prepare_callback_daemon(extras, protocol, use_direct_calls):
     callback_daemon = None
-    protocol = protocol.lower() if protocol else None
 
     if use_direct_calls:
         callback_daemon = DummyHooksCallbackDaemon()

rhodecode/lib/middleware/simplegit.py

@@ -76,7 +76,8 b' class SimpleGit(simplevcs.SimpleVCS):'
         return 'pull'
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
-        return self.scm_app.create_git_wsgi_app(repo_path, repo_name, config)
+        return self.scm_app.create_git_wsgi_app(
+            repo_path, repo_name, config)
 
     def _create_config(self, extras, repo_name):
         extras['git_update_server_info'] = utils2.str2bool(

rhodecode/lib/middleware/simplehg.py

@@ -71,7 +71,8 b' class SimpleHg(simplevcs.SimpleVCS):'
         return 'pull'
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
-        return self.scm_app.create_hg_wsgi_app(repo_path, repo_name, config)
+        return self.scm_app.create_hg_wsgi_app(
+            repo_path, repo_name, config)
 
     def _create_config(self, extras, repo_name):
         config = utils.make_db_config(repo=repo_name)

rhodecode/lib/middleware/simplesvn.py

@@ -89,10 +89,6 b' class SimpleSvnApp(object):'
             if h.lower() not in self.IGNORED_HEADERS
         ]
 
-        # Add custom response header to indicate that this is a VCS response
-        # and which backend is used.
-        headers.append(('X-RhodeCode-Backend', 'svn'))
-
         return headers
 
 

rhodecode/lib/middleware/simplevcs.py

@@ -26,6 +26,7 b" It's implemented with basic auth functio"
 import os
 import logging
 import importlib
+import re
 from functools import wraps
 
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
@@ -41,15 +42,16 b' from rhodecode.lib.exceptions import ('
     NotAllowedToCreateUserError)
 from rhodecode.lib.hooks_daemon import prepare_callback_daemon
 from rhodecode.lib.middleware import appenlight
-from rhodecode.lib.middleware.utils import scm_app
+from rhodecode.lib.middleware.utils import scm_app, scm_app_http
 from rhodecode.lib.utils import (
-    is_valid_repo, get_rhodecode_realm, get_rhodecode_base_path)
-from rhodecode.lib.utils2 import safe_str, fix_PATH, str2bool
+    is_valid_repo, get_rhodecode_realm, get_rhodecode_base_path, SLUG_RE)
+from rhodecode.lib.utils2 import safe_str, fix_PATH, str2bool, safe_unicode
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.lib.vcs.backends import base
 from rhodecode.model import meta
-from rhodecode.model.db import User, Repository
+from rhodecode.model.db import User, Repository, PullRequest
 from rhodecode.model.scm import ScmModel
+from rhodecode.model.pull_request import PullRequestModel
 
 
 log = logging.getLogger(__name__)
@@ -83,12 +85,26 b' class SimpleVCS(object):'
 
     SCM = 'unknown'
 
+    acl_repo_name = None
+    url_repo_name = None
+    vcs_repo_name = None
+
+    # We have to handle requests to shadow repositories different than requests
+    # to normal repositories. Therefore we have to distinguish them. To do this
+    # we use this regex which will match only on URLs pointing to shadow
+    # repositories.
+    shadow_repo_re = re.compile(
+        '(?P<groups>(?:{slug_pat}/)*)'  # repo groups
+        '(?P<target>{slug_pat})/'       # target repo
+        'pull-request/(?P<pr_id>\d+)/'  # pull request
+        'repository$'                   # shadow repo
+        .format(slug_pat=SLUG_RE.pattern))
+
     def __init__(self, application, config, registry):
         self.registry = registry
         self.application = application
         self.config = config
         # re-populated by specialized middleware
-        self.repo_name = None
         self.repo_vcs_config = base.Config()
 
         # base path of repo locations
@@ -101,16 +117,73 b' class SimpleVCS(object):'
             auth_ret_code_detection)
         self.ip_addr = '0.0.0.0'
 
+    def set_repo_names(self, environ):
+        """
+        This will populate the attributes acl_repo_name, url_repo_name,
+        vcs_repo_name and is_shadow_repo. In case of requests to normal (non
+        shadow) repositories all names are equal. In case of requests to a
+        shadow repository the acl-name points to the target repo of the pull
+        request and the vcs-name points to the shadow repo file system path.
+        The url-name is always the URL used by the vcs client program.
+
+        Example in case of a shadow repo:
+            acl_repo_name = RepoGroup/MyRepo
+            url_repo_name = RepoGroup/MyRepo/pull-request/3/repository
+            vcs_repo_name = /repo/base/path/RepoGroup/.__shadow_MyRepo_pr-3'
+        """
+        # First we set the repo name from URL for all attributes. This is the
+        # default if handling normal (non shadow) repo requests.
+        self.url_repo_name = self._get_repository_name(environ)
+        self.acl_repo_name = self.vcs_repo_name = self.url_repo_name
+        self.is_shadow_repo = False
+
+        # Check if this is a request to a shadow repository.
+        match = self.shadow_repo_re.match(self.url_repo_name)
+        if match:
+            match_dict = match.groupdict()
+
+            # Build acl repo name from regex match.
+            acl_repo_name = safe_unicode('{groups}{target}'.format(
+                groups=match_dict['groups'] or '',
+                target=match_dict['target']))
+
+            # Retrieve pull request instance by ID from regex match.
+            pull_request = PullRequest.get(match_dict['pr_id'])
+
+            # Only proceed if we got a pull request and if acl repo name from
+            # URL equals the target repo name of the pull request.
+            if pull_request and (acl_repo_name ==
+                                 pull_request.target_repo.repo_name):
+                # Get file system path to shadow repository.
+                workspace_id = PullRequestModel()._workspace_id(pull_request)
+                target_vcs = pull_request.target_repo.scm_instance()
+                vcs_repo_name = target_vcs._get_shadow_repository_path(
+                    workspace_id)
+
+                # Store names for later usage.
+                self.vcs_repo_name = vcs_repo_name
+                self.acl_repo_name = acl_repo_name
+                self.is_shadow_repo = True
+
+        log.debug('Repository names: %s', {
+            'acl_repo_name': self.acl_repo_name,
+            'url_repo_name': self.url_repo_name,
+            'vcs_repo_name': self.vcs_repo_name,
+        })
+
     @property
     def scm_app(self):
-        custom_implementation = self.config.get('vcs.scm_app_implementation')
-        if custom_implementation and custom_implementation != 'pyro4':
-            log.info(
-                "Using custom implementation of scm_app: %s",
-                custom_implementation)
+        custom_implementation = self.config['vcs.scm_app_implementation']
+        if custom_implementation == 'http':
+            log.info('Using HTTP implementation of scm app.')
+            scm_app_impl = scm_app_http
+        elif custom_implementation == 'pyro4':
+            log.info('Using Pyro implementation of scm app.')
+            scm_app_impl = scm_app
+        else:
+            log.info('Using custom implementation of scm_app: "{}"'.format(
+                custom_implementation))
             scm_app_impl = importlib.import_module(custom_implementation)
-        else:
-            scm_app_impl = scm_app
         return scm_app_impl
 
     def _get_by_id(self, repo_name):
@@ -149,7 +222,7 b' class SimpleVCS(object):'
                 repo_name, db_repo.repo_type, scm_type)
             return False
 
-        return is_valid_repo(repo_name, base_path, expect_scm=scm_type)
+        return is_valid_repo(repo_name, base_path, explicit_scm=scm_type)
 
     def valid_and_active_user(self, user):
         """
@@ -233,11 +306,11 b' class SimpleVCS(object):'
             log.debug('User not allowed to proceed, %s', reason)
             return HTTPNotAcceptable(reason)(environ, start_response)
 
-        if not self.repo_name:
-            log.warning('Repository name is empty: %s', self.repo_name)
+        if not self.url_repo_name:
+            log.warning('Repository name is empty: %s', self.url_repo_name)
             # failed to get repo name, we fail now
             return HTTPNotFound()(environ, start_response)
-        log.debug('Extracted repo name is %s', self.repo_name)
+        log.debug('Extracted repo name is %s', self.url_repo_name)
 
         ip_addr = get_ip_addr(environ)
         username = None
@@ -251,6 +324,15 b' class SimpleVCS(object):'
         action = self._get_action(environ)
 
         # ======================================================================
+        # Check if this is a request to a shadow repository of a pull request.
+        # In this case only pull action is allowed.
+        # ======================================================================
+        if self.is_shadow_repo and action != 'pull':
+            reason = 'Only pull action is allowed for shadow repositories.'
+            log.debug('User not allowed to proceed, %s', reason)
+            return HTTPNotAcceptable(reason)(environ, start_response)
+
+        # ======================================================================
         # CHECK ANONYMOUS PERMISSION
         # ======================================================================
         if action in ['pull', 'push']:
@@ -259,7 +341,7 b' class SimpleVCS(object):'
             if anonymous_user.active:
                 # ONLY check permissions if the user is activated
                 anonymous_perm = self._check_permission(
-                    action, anonymous_user, self.repo_name, ip_addr)
+                    action, anonymous_user, self.acl_repo_name, ip_addr)
             else:
                 anonymous_perm = False
 
@@ -324,7 +406,7 b' class SimpleVCS(object):'
 
                 # check permissions for this repository
                 perm = self._check_permission(
-                    action, user, self.repo_name, ip_addr)
+                    action, user, self.acl_repo_name, ip_addr)
                 if not perm:
                     return HTTPForbidden()(environ, start_response)
 
@@ -332,30 +414,31 b' class SimpleVCS(object):'
         # in hooks executed by rhodecode
         check_locking = _should_check_locking(environ.get('QUERY_STRING'))
         extras = vcs_operation_context(
-            environ, repo_name=self.repo_name, username=username,
-            action=action, scm=self.SCM,
-            check_locking=check_locking)
+            environ, repo_name=self.acl_repo_name, username=username,
+            action=action, scm=self.SCM, check_locking=check_locking,
+            is_shadow_repo=self.is_shadow_repo
+        )
 
         # ======================================================================
         # REQUEST HANDLING
         # ======================================================================
-        str_repo_name = safe_str(self.repo_name)
-        repo_path = os.path.join(safe_str(self.basepath), str_repo_name)
+        repo_path = os.path.join(
+            safe_str(self.basepath), safe_str(self.vcs_repo_name))
         log.debug('Repository path is %s', repo_path)
 
         fix_PATH()
 
         log.info(
             '%s action on %s repo "%s" by "%s" from %s',
-            action, self.SCM, str_repo_name, safe_str(username), ip_addr)
+            action, self.SCM, safe_str(self.url_repo_name),
+            safe_str(username), ip_addr)
 
         return self._generate_vcs_response(
-            environ, start_response, repo_path, self.repo_name, extras, action)
+            environ, start_response, repo_path, extras, action)
 
     @initialize_generator
     def _generate_vcs_response(
-            self, environ, start_response, repo_path, repo_name, extras,
-            action):
+            self, environ, start_response, repo_path, extras, action):
         """
         Returns a generator for the response content.
 
@@ -365,9 +448,9 b' class SimpleVCS(object):'
         the first chunk is produced by the underlying WSGI application.
         """
         callback_daemon, extras = self._prepare_callback_daemon(extras)
-        config = self._create_config(extras, repo_name)
+        config = self._create_config(extras, self.acl_repo_name)
         log.debug('HOOKS extras is %s', extras)
-        app = self._create_wsgi_app(repo_path, repo_name, config)
+        app = self._create_wsgi_app(repo_path, self.url_repo_name, config)
 
         try:
             with callback_daemon:
@@ -386,6 +469,8 b' class SimpleVCS(object):'
                 for chunk in response:
                     yield chunk
         except Exception as exc:
+            # TODO: martinb: Exceptions are only raised in case of the Pyro4
+            # backend. Refactor this except block after dropping Pyro4 support.
             # TODO: johbo: Improve "translating" back the exception.
             if getattr(exc, '_vcs_kind', None) == 'repo_locked':
                 exc = HTTPLockedRC(*exc.args)
@@ -404,7 +489,7 b' class SimpleVCS(object):'
             # invalidate cache on push
             try:
                 if action == 'push':
-                    self._invalidate_cache(repo_name)
+                    self._invalidate_cache(self.url_repo_name)
             finally:
                 meta.Session.remove()
 

rhodecode/lib/middleware/utils/scm_app_http.py

@@ -39,12 +39,12 b' log = logging.getLogger(__name__)'
 
 def create_git_wsgi_app(repo_path, repo_name, config):
     url = _vcs_streaming_url() + 'git/'
-    return VcsHttpProxy(url, repo_path, repo_name, config, 'git')
+    return VcsHttpProxy(url, repo_path, repo_name, config)
 
 
 def create_hg_wsgi_app(repo_path, repo_name, config):
     url = _vcs_streaming_url() + 'hg/'
-    return VcsHttpProxy(url, repo_path, repo_name, config, 'hg')
+    return VcsHttpProxy(url, repo_path, repo_name, config)
 
 
 def _vcs_streaming_url():
@@ -67,7 +67,7 b' class VcsHttpProxy(object):'
     server as well.
     """
 
-    def __init__(self, url, repo_path, repo_name, config, backend):
+    def __init__(self, url, repo_path, repo_name, config):
         """
         :param str url: The URL of the VCSServer to call.
         """
@@ -75,14 +75,11 b' class VcsHttpProxy(object):'
         self._repo_name = repo_name
         self._repo_path = repo_path
         self._config = config
-        self._backend = backend
         log.debug(
             "Creating VcsHttpProxy for repo %s, url %s",
             repo_name, url)
 
     def __call__(self, environ, start_response):
-        status = '200 OK'
-
         config = msgpack.packb(self._config)
         request = webob.request.Request(environ)
         request_headers = request.headers
@@ -93,6 +90,7 b' class VcsHttpProxy(object):'
             'X-RC-Path-Info': environ['PATH_INFO'],
             # TODO: johbo: Avoid encoding and put this into payload?
             'X-RC-Repo-Config': base64.b64encode(config),
+            'X-RC-Locked-Status-Code': rhodecode.CONFIG.get('lock_ret_code')
         })
 
         data = environ['wsgi.input'].read()
@@ -116,12 +114,11 b' class VcsHttpProxy(object):'
             if not wsgiref.util.is_hop_by_hop(h)
         ]
 
-        # Add custom response header to indicate that this is a VCS response
-        # and which backend is used.
-        response_headers.append(('X-RhodeCode-Backend', self._backend))
+        # Build status argument for start_reponse callable.
+        status = '{status_code} {reason_phrase}'.format(
+            status_code=response.status_code,
+            reason_phrase=response.reason)
 
-        # TODO: johbo: Better way to get the status including text?
-        status = str(response.status_code)
         start_response(status, response_headers)
         return _maybe_stream(response)
 

rhodecode/lib/middleware/vcs.py

@@ -174,25 +174,31 b' class VCSMiddleware(object):'
             # translate the _REPO_ID into real repo NAME for usage
             # in middleware
             environ['PATH_INFO'] = vcs_handler._get_by_id(environ['PATH_INFO'])
-            repo_name = vcs_handler._get_repository_name(environ)
+
+            # Set acl, url and vcs repo names.
+            vcs_handler.set_repo_names(environ)
 
             # check for type, presence in database and on filesystem
             if not vcs_handler.is_valid_and_existing_repo(
-                    repo_name, vcs_handler.basepath, vcs_handler.SCM):
+                    vcs_handler.acl_repo_name,
+                    vcs_handler.basepath,
+                    vcs_handler.SCM):
                 return HTTPNotFound()(environ, start_response)
 
             # TODO: johbo: Needed for the Pyro4 backend and Mercurial only.
             # Remove once we fully switched to the HTTP backend.
-            environ['REPO_NAME'] = repo_name
+            environ['REPO_NAME'] = vcs_handler.url_repo_name
 
-            # register repo_name and it's config back to the handler
-            vcs_handler.repo_name = repo_name
-            vcs_handler.repo_vcs_config = self.vcs_config(repo_name)
+            # register repo config back to the handler
+            vcs_handler.repo_vcs_config = self.vcs_config(
+                vcs_handler.acl_repo_name)
 
+            # Wrap handler in middlewares if they are enabled.
             vcs_handler = self.wrap_in_gzip_if_enabled(
                 vcs_handler, self.config)
             vcs_handler, _ = wrap_in_appenlight_if_enabled(
                 vcs_handler, self.config, self.appenlight_client)
+
             return vcs_handler(environ, start_response)
 
         return self.application(environ, start_response)

rhodecode/lib/utils.py

@@ -33,6 +33,7 b' import tempfile'
 import traceback
 import tarfile
 import warnings
+import hashlib
 from os.path import join as jn
 
 import paste
@@ -58,26 +59,21 b' log = logging.getLogger(__name__)'
 
 REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}__.*')
 
-_license_cache = None
-
+# String which contains characters that are not allowed in slug names for
+# repositories or repository groups. It is properly escaped to use it in
+# regular expressions.
+SLUG_BAD_CHARS = re.escape('`?=[]\;\'"<>,/~!@#$%^&*()+{}|:')
 
-def recursive_replace(str_, replace=' '):
-    """
-    Recursive replace of given sign to just one instance
-
-    :param str_: given string
-    :param replace: char to find and replace multiple instances
+# Regex that matches forbidden characters in repo/group slugs.
+SLUG_BAD_CHAR_RE = re.compile('[{}]'.format(SLUG_BAD_CHARS))
 
-    Examples::
-    >>> recursive_replace("Mighty---Mighty-Bo--sstones",'-')
-    'Mighty-Mighty-Bo-sstones'
-    """
+# Regex that matches allowed characters in repo/group slugs.
+SLUG_GOOD_CHAR_RE = re.compile('[^{}]'.format(SLUG_BAD_CHARS))
 
-    if str_.find(replace * 2) == -1:
-        return str_
-    else:
-        str_ = str_.replace(replace * 2, replace)
-        return recursive_replace(str_, replace)
+# Regex that matches whole repo/group slugs.
+SLUG_RE = re.compile('[^{}]+'.format(SLUG_BAD_CHARS))
+
+_license_cache = None
 
 
 def repo_name_slug(value):
@@ -86,14 +82,12 b' def repo_name_slug(value):'
     This function is called on each creation/modification
     of repository to prevent bad names in repo
     """
+    replacement_char = '-'
 
     slug = remove_formatting(value)
-    slug = strip_tags(slug)
-
-    for c in """`?=[]\;'"<>,/~!@#$%^&*()+{}|: """:
-        slug = slug.replace(c, '-')
-    slug = recursive_replace(slug, '-')
-    slug = collapse(slug, '-')
+    slug = SLUG_BAD_CHAR_RE.sub('', slug)
+    slug = re.sub('[\s]+', '-', slug)
+    slug = collapse(slug, replacement_char)
     return slug
 
 
@@ -1009,3 +1003,17 b' def get_registry(request):'
         return request.registry
     except AttributeError:
         return get_current_registry()
+
+
+def generate_platform_uuid():
+    """
+    Generates platform UUID based on it's name
+    """
+    import platform
+
+    try:
+        uuid_list = [platform.platform()]
+        return hashlib.sha256(':'.join(uuid_list)).hexdigest()
+    except Exception as e:
+        log.error('Failed to generate host uuid: %s' % e)
+        return 'UNDEFINED'

rhodecode/lib/utils2.py

@@ -96,7 +96,7 b' def __get_lem(extra_mapping=None):'
 
 def str2bool(_str):
     """
-    returs True/False value from given string, it tries to translate the
+    returns True/False value from given string, it tries to translate the
     string into boolean
 
     :param _str: string value to translate into boolean
@@ -893,3 +893,44 b' def get_routes_generator_for_server_url('
         environ['wsgi.url_scheme'] = 'https'
 
     return routes.util.URLGenerator(rhodecode.CONFIG['routes.map'], environ)
+
+
+def glob2re(pat):
+    """
+    Translate a shell PATTERN to a regular expression.
+
+    There is no way to quote meta-characters.
+    """
+
+    i, n = 0, len(pat)
+    res = ''
+    while i < n:
+        c = pat[i]
+        i = i+1
+        if c == '*':
+            #res = res + '.*'
+            res = res + '[^/]*'
+        elif c == '?':
+            #res = res + '.'
+            res = res + '[^/]'
+        elif c == '[':
+            j = i
+            if j < n and pat[j] == '!':
+                j = j+1
+            if j < n and pat[j] == ']':
+                j = j+1
+            while j < n and pat[j] != ']':
+                j = j+1
+            if j >= n:
+                res = res + '\\['
+            else:
+                stuff = pat[i:j].replace('\\','\\\\')
+                i = j+1
+                if stuff[0] == '!':
+                    stuff = '^' + stuff[1:]
+                elif stuff[0] == '^':
+                    stuff = '\\' + stuff
+                res = '%s[%s]' % (res, stuff)
+        else:
+            res = res + re.escape(c)
+    return res + '\Z(?ms)'

rhodecode/lib/vcs/__init__.py

@@ -35,7 +35,7 b" VERSION = (0, 5, 0, 'dev')"
 
 import atexit
 import logging
-import subprocess
+import subprocess32
 import time
 import urlparse
 from cStringIO import StringIO
@@ -46,7 +46,7 b' from Pyro4.errors import CommunicationEr'
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.backends import get_vcs_instance, get_backend
 from rhodecode.lib.vcs.exceptions import (
-    VCSError, RepositoryError, CommitError)
+    VCSError, RepositoryError, CommitError, VCSCommunicationError)
 
 log = logging.getLogger(__name__)
 
@@ -99,6 +99,7 b' def connect_pyro4(server_and_port):'
         connection.Git = None
         connection.Hg = None
         connection.Svn = None
+        connection.Service = None
 
 
 def connect_http(server_and_port):
@@ -108,11 +109,13 b' def connect_http(server_and_port):'
     session_factory = client_http.ThreadlocalSessionFactory()
 
     connection.Git = client_http.RepoMaker(
-        server_and_port, '/git', session_factory)
+        server_and_port, '/git', 'git', session_factory)
     connection.Hg = client_http.RepoMaker(
-        server_and_port, '/hg', session_factory)
+        server_and_port, '/hg', 'hg', session_factory)
     connection.Svn = client_http.RepoMaker(
-        server_and_port, '/svn', session_factory)
+        server_and_port, '/svn', 'svn', session_factory)
+    connection.Service = client_http.ServiceConnection(
+        server_and_port, '/_service', session_factory)
 
     scm_app.HG_REMOTE_WSGI = client_http.VcsHttpProxy(
         server_and_port, '/proxy/hg')
@@ -124,9 +127,10 b' def connect_http(server_and_port):'
         connection.Git = None
         connection.Hg = None
         connection.Svn = None
+        connection.Service = None
 
 
-def connect_vcs(server_and_port, protocol='pyro4'):
+def connect_vcs(server_and_port, protocol):
     """
     Initializes the connection to the vcs server.
 
@@ -137,11 +141,13 b' def connect_vcs(server_and_port, protoco'
         connect_pyro4(server_and_port)
     elif protocol == 'http':
         connect_http(server_and_port)
+    else:
+        raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 # TODO: johbo: This function should be moved into our test suite, there is
 # no reason to support starting the vcsserver in Enterprise itself.
-def start_vcs_server(server_and_port, protocol='pyro4', log_level=None):
+def start_vcs_server(server_and_port, protocol, log_level=None):
     """
     Starts the vcs server in a subprocess.
     """
@@ -150,10 +156,12 b' def start_vcs_server(server_and_port, pr'
         return _start_http_vcs_server(server_and_port, log_level)
     elif protocol == 'pyro4':
         return _start_pyro4_vcs_server(server_and_port, log_level)
+    else:
+        raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 def _start_pyro4_vcs_server(server_and_port, log_level=None):
-    _try_to_shutdown_running_server(server_and_port)
+    _try_to_shutdown_running_server(server_and_port, protocol='pyro4')
     host, port = server_and_port.rsplit(":", 1)
     host = host.strip('[]')
     args = [
@@ -161,7 +169,7 b' def _start_pyro4_vcs_server(server_and_p'
         '--threadpool', '32']
     if log_level:
         args += ['--log-level', log_level]
-    proc = subprocess.Popen(args)
+    proc = subprocess32.Popen(args)
 
     def cleanup_server_process():
         proc.kill()
@@ -176,9 +184,9 b' def _start_http_vcs_server(server_and_po'
 
     host, port = server_and_port.rsplit(":", 1)
     args = [
-        'pserve', 'vcsserver/development_pyramid.ini',
+        'pserve', 'rhodecode/tests/vcsserver_http.ini',
         'http_port=%s' % (port, ), 'http_host=%s' % (host, )]
-    proc = subprocess.Popen(args)
+    proc = subprocess32.Popen(args)
 
     def cleanup_server_process():
         proc.kill()
@@ -188,18 +196,22 b' def _start_http_vcs_server(server_and_po'
     _wait_until_vcs_server_is_reachable(server)
 
 
-def _wait_until_vcs_server_is_reachable(server):
-    while xrange(80):  # max 40s of sleep
+def _wait_until_vcs_server_is_reachable(server, timeout=40):
+    begin = time.time()
+    while (time.time() - begin) < timeout:
         try:
             server.ping()
-            break
-        except (CommunicationError, pycurl.error):
-            pass
+            return
+        except (VCSCommunicationError, CommunicationError, pycurl.error):
+            log.debug('VCSServer not started yet, retry to connect.')
         time.sleep(0.5)
+    raise Exception(
+        'Starting the VCSServer failed or took more than {} '
+        'seconds.'.format(timeout))
 
 
-def _try_to_shutdown_running_server(server_and_port):
-    server = create_vcsserver_proxy(server_and_port)
+def _try_to_shutdown_running_server(server_and_port, protocol):
+    server = create_vcsserver_proxy(server_and_port, protocol)
     try:
         server.shutdown()
     except (CommunicationError, pycurl.error):
@@ -207,15 +219,17 b' def _try_to_shutdown_running_server(serv'
 
     # TODO: Not sure why this is important, but without it the following start
     # of the server fails.
-    server = create_vcsserver_proxy(server_and_port)
+    server = create_vcsserver_proxy(server_and_port, protocol)
     server.ping()
 
 
-def create_vcsserver_proxy(server_and_port, protocol='pyro4'):
+def create_vcsserver_proxy(server_and_port, protocol):
     if protocol == 'pyro4':
         return _create_vcsserver_proxy_pyro4(server_and_port)
     elif protocol == 'http':
         return _create_vcsserver_proxy_http(server_and_port)
+    else:
+        raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 def _create_vcsserver_proxy_pyro4(server_and_port):

rhodecode/lib/vcs/backends/__init__.py

@@ -22,6 +22,7 b''
 VCS Backends module
 """
 
+import os
 import logging
 
 from pprint import pformat
@@ -42,11 +43,21 b' def get_vcs_instance(repo_path, *args, *'
     for the path it returns None. Arguments and keyword arguments are passed
     to the vcs backend repository class.
     """
+    from rhodecode.lib.utils2 import safe_str
+
+    explicit_vcs_alias = kwargs.pop('_vcs_alias', None)
     try:
-        vcs_alias = get_scm(repo_path)[0]
+        vcs_alias = safe_str(explicit_vcs_alias or get_scm(repo_path)[0])
         log.debug(
-            'Creating instance of %s repository from %s', vcs_alias, repo_path)
+            'Creating instance of %s repository from %s', vcs_alias,
+            safe_str(repo_path))
         backend = get_backend(vcs_alias)
+
+        if explicit_vcs_alias:
+            # do final verification of existance of the path, this does the
+            # same as get_scm() call which we skip in explicit_vcs_alias
+            if not os.path.isdir(repo_path):
+                raise VCSError("Given path %s is not a directory" % repo_path)
     except VCSError:
         log.exception(
             'Perhaps this repository is in db and not in '
@@ -76,3 +87,12 b' def get_supported_backends():'
     Returns list of aliases of supported backends.
     """
     return settings.BACKENDS.keys()
+
+
+def get_vcsserver_version():
+    from rhodecode.lib.vcs import connection
+    data = connection.Service.get_vcsserver_service_data()
+    if data and 'version' in data:
+        return data['version']
+
+    return None

rhodecode/lib/vcs/backends/base.py

@@ -53,7 +53,7 b' FILEMODE_EXECUTABLE = 0100755'
 Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id'))
 MergeResponse = collections.namedtuple(
     'MergeResponse',
-    ('possible', 'executed', 'merge_commit_id', 'failure_reason'))
+    ('possible', 'executed', 'merge_ref', 'failure_reason'))
 
 
 class MergeFailureReason(object):
@@ -94,8 +94,49 b' class MergeFailureReason(object):'
     # The target repository is locked
     TARGET_IS_LOCKED = 7
 
+    # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead.
     # A involved commit could not be found.
-    MISSING_COMMIT = 8
+    _DEPRECATED_MISSING_COMMIT = 8
+
+    # The target repo reference is missing.
+    MISSING_TARGET_REF = 9
+
+    # The source repo reference is missing.
+    MISSING_SOURCE_REF = 10
+
+    # The merge was not successful, there are conflicts related to sub
+    # repositories.
+    SUBREPO_MERGE_FAILED = 11
+
+
+class UpdateFailureReason(object):
+    """
+    Enumeration with all the reasons why the pull request update could fail.
+
+    DO NOT change the number of the reasons, as they may be stored in the
+    database.
+
+    Changing the name of a reason is acceptable and encouraged to deprecate old
+    reasons.
+    """
+
+    # Everything went well.
+    NONE = 0
+
+    # An unexpected exception was raised. Check the logs for more details.
+    UNKNOWN = 1
+
+    # The pull request is up to date.
+    NO_CHANGE = 2
+
+    # The pull request has a reference type that is not supported for update.
+    WRONG_REF_TPYE = 3
+
+    # Update failed because the target reference is missing.
+    MISSING_TARGET_REF = 4
+
+    # Update failed because the source reference is missing.
+    MISSING_SOURCE_REF = 5
 
 
 class BaseRepository(object):
@@ -393,9 +434,9 b' class BaseRepository(object):'
             on top of the target instead of being merged.
         """
         if dry_run:
-            message = message or 'sample_message'
-            user_email = user_email or '[e-mail]'
-            user_name = user_name or 'user name'
+            message = message or 'dry_run_merge_message'
+            user_email = user_email or '[e-mail]'
+            user_name = user_name or 'Dry-Run User'
         else:
             if not user_name:
                 raise ValueError('user_name cannot be empty')
@@ -421,7 +462,7 b' class BaseRepository(object):'
 
     def _merge_repo(self, shadow_repository_path, target_ref,
                     source_repo, source_ref, merge_message,
-                    merger_name, merger_email, dry_run=False):
+                    merger_name, merger_email, dry_run=False, use_rebase=False):
         """Internal implementation of merge."""
         raise NotImplementedError
 
@@ -628,7 +669,8 b' class BaseCommit(object):'
         return u'%s:%s' % (self.idx, self.short_id)
 
     def __eq__(self, other):
-        return self.raw_id == other.raw_id
+        same_instance = isinstance(other, self.__class__)
+        return same_instance and self.raw_id == other.raw_id
 
     def __json__(self):
         parents = []
@@ -860,7 +902,7 b' class BaseCommit(object):'
 
         prefix = self._validate_archive_prefix(prefix)
 
-        mtime = mtime or time.time()
+        mtime = mtime or time.mktime(self.date.timetuple())
 
         file_info = []
         cur_rev = self.repository.get_commit(commit_id=self.raw_id)

rhodecode/lib/vcs/backends/git/__init__.py

@@ -33,7 +33,7 b' from rhodecode.lib.vcs.backends.git.inme'
 log = logging.getLogger(__name__)
 
 
-def discover_git_version():
+def discover_git_version(raise_on_exc=False):
     """
     Returns the string as it was returned by running 'git --version'
 
@@ -44,4 +44,6 b' def discover_git_version():'
         return connection.Git.discover_git_version()
     except Exception:
         log.warning("Failed to discover the Git version", exc_info=True)
+        if raise_on_exc:
+            raise
         return ''

rhodecode/lib/vcs/backends/git/diff.py

@@ -32,11 +32,13 b' class GitDiff(base.Diff):'
     _header_re = re.compile(r"""
         #^diff[ ]--git
             [ ]"?a/(?P<a_path>.+?)"?[ ]"?b/(?P<b_path>.+?)"?\n
-        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n
-           ^rename[ ]from[ ](?P<rename_from>[^\r\n]+)\n
-           ^rename[ ]to[ ](?P<rename_to>[^\r\n]+)(?:\n|$))?
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
+        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?
+        (?:^rename[ ]from[ ](?P<rename_from>[^\r\n]+)\n
+           ^rename[ ]to[ ](?P<rename_to>[^\r\n]+)(?:\n|$))?
+        (?:^copy[ ]from[ ](?P<copy_from>[^\r\n]+)\n
+           ^copy[ ]to[ ](?P<copy_to>[^\r\n]+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

rhodecode/lib/vcs/backends/git/repository.py

@@ -36,11 +36,10 b' from rhodecode.lib.utils import safe_uni'
 from rhodecode.lib.vcs import connection, path as vcspath
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
-    MergeFailureReason)
+    MergeFailureReason, Reference)
 from rhodecode.lib.vcs.backends.git.commit import GitCommit
 from rhodecode.lib.vcs.backends.git.diff import GitDiff
 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
-from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError,
     RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)
@@ -865,18 +864,29 b' class GitRepository(BaseRepository):'
         shadow_repo._checkout(pr_branch, create=True)
         try:
             shadow_repo._local_fetch(source_repo.path, source_ref.name)
-        except RepositoryError as e:
+        except RepositoryError:
             log.exception('Failure when doing local fetch on git shadow repo')
             return MergeResponse(
-                False, False, None, MergeFailureReason.MISSING_COMMIT)
+                False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
 
-        merge_commit_id = None
+        merge_ref = None
         merge_failure_reason = MergeFailureReason.NONE
         try:
             shadow_repo._local_merge(merge_message, merger_name, merger_email,
                                      [source_ref.commit_id])
             merge_possible = True
-        except RepositoryError as e:
+
+            # Need to reload repo to invalidate the cache, or otherwise we
+            # cannot retrieve the merge commit.
+            shadow_repo = GitRepository(shadow_repository_path)
+            merge_commit_id = shadow_repo.branches[pr_branch]
+
+            # Set a reference pointing to the merge commit. This reference may
+            # be used to easily identify the last successful merge commit in
+            # the shadow repository.
+            shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id)
+            merge_ref = Reference('branch', 'pr-merge', merge_commit_id)
+        except RepositoryError:
             log.exception('Failure when doing local merge on git shadow repo')
             merge_possible = False
             merge_failure_reason = MergeFailureReason.MERGE_FAILED
@@ -887,11 +897,7 b' class GitRepository(BaseRepository):'
                     pr_branch, self.path, target_ref.name, enable_hooks=True,
                     rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA'))
                 merge_succeeded = True
-                # Need to reload repo to invalidate the cache, or otherwise we
-                # cannot retrieve the merge commit.
-                shadow_repo = GitRepository(shadow_repository_path)
-                merge_commit_id = shadow_repo.branches[pr_branch]
-            except RepositoryError as e:
+            except RepositoryError:
                 log.exception(
                     'Failure when doing local push on git shadow repo')
                 merge_succeeded = False
@@ -900,7 +906,7 b' class GitRepository(BaseRepository):'
             merge_succeeded = False
 
         return MergeResponse(
-            merge_possible, merge_succeeded, merge_commit_id,
+            merge_possible, merge_succeeded, merge_ref,
             merge_failure_reason)
 
     def _get_shadow_repository_path(self, workspace_id):

rhodecode/lib/vcs/backends/hg/__init__.py

@@ -21,7 +21,28 b''
 """
 HG module
 """
+import logging
 
+from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
 from rhodecode.lib.vcs.backends.hg.repository import MercurialRepository
+
+
+log = logging.getLogger(__name__)
+
+
+def discover_hg_version(raise_on_exc=False):
+    """
+    Returns the string as it was returned by running 'git --version'
+
+    It will return an empty string in case the connection is not initialized
+    or no vcsserver is available.
+    """
+    try:
+        return connection.Hg.discover_hg_version()
+    except Exception:
+        log.warning("Failed to discover the HG version", exc_info=True)
+        if raise_on_exc:
+            raise
+        return ''

rhodecode/lib/vcs/backends/hg/repository.py

@@ -38,13 +38,13 b' from rhodecode.lib.utils import safe_uni'
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
-    MergeFailureReason)
+    MergeFailureReason, Reference)
 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
-    TagDoesNotExistError, CommitDoesNotExistError)
+    TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError)
 
 hexlify = binascii.hexlify
 nullid = "\0" * 20
@@ -673,11 +673,16 b' class MercurialRepository(BaseRepository'
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
 
-        if (target_ref.type == 'branch' and
-                len(self._heads(target_ref.name)) != 1):
+        try:
+            if (target_ref.type == 'branch' and
+                    len(self._heads(target_ref.name)) != 1):
+                return MergeResponse(
+                    False, False, None,
+                    MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
+        except CommitDoesNotExistError as e:
+            log.exception('Failure when looking up branch heads on hg target')
             return MergeResponse(
-                False, False, None,
-                MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
+                False, False, None, MergeFailureReason.MISSING_TARGET_REF)
 
         shadow_repo = self._get_shadow_instance(shadow_repository_path)
 
@@ -688,12 +693,12 b' class MercurialRepository(BaseRepository'
             log.debug('Pulling in source reference %s', source_ref)
             source_repo._validate_pull_reference(source_ref)
             shadow_repo._local_pull(source_repo.path, source_ref)
-        except CommitDoesNotExistError as e:
+        except CommitDoesNotExistError:
             log.exception('Failure when doing local pull on hg shadow repo')
             return MergeResponse(
-                False, False, None, MergeFailureReason.MISSING_COMMIT)
+                False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
 
-        merge_commit_id = None
+        merge_ref = None
         merge_failure_reason = MergeFailureReason.NONE
 
         try:
@@ -701,7 +706,18 b' class MercurialRepository(BaseRepository'
                 target_ref, merge_message, merger_name, merger_email,
                 source_ref, use_rebase=use_rebase)
             merge_possible = True
-        except RepositoryError as e:
+
+            # Set a bookmark pointing to the merge commit. This bookmark may be
+            # used to easily identify the last successful merge commit in the
+            # shadow repository.
+            shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
+            merge_ref = Reference('book', 'pr-merge', merge_commit_id)
+        except SubrepoMergeError:
+            log.exception(
+                'Subrepo merge error during local merge on hg shadow repo.')
+            merge_possible = False
+            merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED
+        except RepositoryError:
             log.exception('Failure when doing local merge on hg shadow repo')
             merge_possible = False
             merge_failure_reason = MergeFailureReason.MERGE_FAILED
@@ -737,12 +753,8 b' class MercurialRepository(BaseRepository'
         else:
             merge_succeeded = False
 
-        if dry_run:
-            merge_commit_id = None
-
         return MergeResponse(
-            merge_possible, merge_succeeded, merge_commit_id,
-            merge_failure_reason)
+            merge_possible, merge_succeeded, merge_ref, merge_failure_reason)
 
     def _get_shadow_instance(
             self, shadow_repository_path, enable_hooks=False):

rhodecode/lib/vcs/backends/svn/__init__.py

@@ -21,6 +21,27 b''
 """
 SVN module
 """
+import logging
 
+from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.svn.commit import SubversionCommit
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
+
+
+log = logging.getLogger(__name__)
+
+
+def discover_svn_version(raise_on_exc=False):
+    """
+    Returns the string as it was returned by running 'git --version'
+
+    It will return an empty string in case the connection is not initialized
+    or no vcsserver is available.
+    """
+    try:
+        return connection.Svn.discover_svn_version()
+    except Exception:
+        log.warning("Failed to discover the SVN version", exc_info=True)
+        if raise_on_exc:
+            raise
+        return ''

rhodecode/lib/vcs/client.py

@@ -25,15 +25,10 b' Provides the implementation of various c'
 
 import copy
 import logging
-import threading
-import urlparse
 import uuid
 import weakref
-from urllib2 import URLError
 
-import msgpack
 import Pyro4
-import requests
 from pyramid.threadlocal import get_current_request
 from Pyro4.errors import CommunicationError, ConnectionClosedError, DaemonError
 
@@ -43,137 +38,6 b' from rhodecode.lib.vcs.conf import setti'
 log = logging.getLogger(__name__)
 
 
-# TODO: mikhail: Keep it in sync with vcsserver's
-# HTTPApplication.ALLOWED_EXCEPTIONS
-EXCEPTIONS_MAP = {
-    'KeyError': KeyError,
-    'URLError': URLError,
-}
-
-
-class HTTPRepoMaker(object):
-    def __init__(self, server_and_port, backend_endpoint):
-        self.url = urlparse.urljoin(
-            'http://%s' % server_and_port, backend_endpoint)
-
-    def __call__(self, path, config, with_wire=None):
-        log.debug('HTTPRepoMaker call on %s', path)
-        return HTTPRemoteRepo(path, config, self.url, with_wire=with_wire)
-
-    def __getattr__(self, name):
-        def f(*args, **kwargs):
-            return self._call(name, *args, **kwargs)
-        return f
-
-    @exceptions.map_vcs_exceptions
-    def _call(self, name, *args, **kwargs):
-        payload = {
-            'id': str(uuid.uuid4()),
-            'method': name,
-            'params': {'args': args, 'kwargs': kwargs}
-        }
-        return _remote_call(self.url, payload, EXCEPTIONS_MAP)
-
-
-class VcsHttpProxy(object):
-
-    CHUNK_SIZE = 16384
-
-    def __init__(self, server_and_port, backend_endpoint):
-        adapter = requests.adapters.HTTPAdapter(max_retries=5)
-        self.base_url = urlparse.urljoin(
-            'http://%s' % server_and_port, backend_endpoint)
-        self.session = requests.Session()
-        self.session.mount('http://', adapter)
-
-    def handle(self, environment, input_data, *args, **kwargs):
-        data = {
-            'environment': environment,
-            'input_data': input_data,
-            'args': args,
-            'kwargs': kwargs
-        }
-        result = self.session.post(
-            self.base_url, msgpack.packb(data), stream=True)
-        return self._get_result(result)
-
-    def _deserialize_and_raise(self, error):
-        exception = Exception(error['message'])
-        try:
-            exception._vcs_kind = error['_vcs_kind']
-        except KeyError:
-            pass
-        raise exception
-
-    def _iterate(self, result):
-        unpacker = msgpack.Unpacker()
-        for line in result.iter_content(chunk_size=self.CHUNK_SIZE):
-            unpacker.feed(line)
-            for chunk in unpacker:
-                yield chunk
-
-    def _get_result(self, result):
-        iterator = self._iterate(result)
-        error = iterator.next()
-        if error:
-            self._deserialize_and_raise(error)
-
-        status = iterator.next()
-        headers = iterator.next()
-
-        return iterator, status, headers
-
-
-class HTTPRemoteRepo(object):
-    def __init__(self, path, config, url, with_wire=None):
-        self.url = url
-        self._wire = {
-            "path": path,
-            "config": config,
-            "context": str(uuid.uuid4()),
-        }
-        if with_wire:
-            self._wire.update(with_wire)
-
-    def __getattr__(self, name):
-        def f(*args, **kwargs):
-            return self._call(name, *args, **kwargs)
-        return f
-
-    @exceptions.map_vcs_exceptions
-    def _call(self, name, *args, **kwargs):
-        log.debug('Calling %s@%s', self.url, name)
-        # TODO: oliver: This is currently necessary pre-call since the
-        # config object is being changed for hooking scenarios
-        wire = copy.deepcopy(self._wire)
-        wire["config"] = wire["config"].serialize()
-        payload = {
-            'id': str(uuid.uuid4()),
-            'method': name,
-            'params': {'wire': wire, 'args': args, 'kwargs': kwargs}
-        }
-        return _remote_call(self.url, payload, EXCEPTIONS_MAP)
-
-    def __getitem__(self, key):
-        return self.revision(key)
-
-
-def _remote_call(url, payload, exceptions_map):
-    response = requests.post(url, data=msgpack.packb(payload))
-    response = msgpack.unpackb(response.content)
-    error = response.get('error')
-    if error:
-        type_ = error.get('type', 'Exception')
-        exc = exceptions_map.get(type_, Exception)
-        exc = exc(error.get('message'))
-        try:
-            exc._vcs_kind = error['_vcs_kind']
-        except KeyError:
-            pass
-        raise exc
-    return response.get('result')
-
-
 class RepoMaker(object):
 
     def __init__(self, proxy_factory):

rhodecode/lib/vcs/client_http.py

@@ -56,10 +56,11 b' EXCEPTIONS_MAP = {'
 
 class RepoMaker(object):
 
-    def __init__(self, server_and_port, backend_endpoint, session_factory):
+    def __init__(self, server_and_port, backend_endpoint, backend_type, session_factory):
         self.url = urlparse.urljoin(
             'http://%s' % server_and_port, backend_endpoint)
         self._session_factory = session_factory
+        self.backend_type = backend_type
 
     def __call__(self, path, config, with_wire=None):
         log.debug('RepoMaker call on %s', path)
@@ -77,6 +78,30 b' class RepoMaker(object):'
         payload = {
             'id': str(uuid.uuid4()),
             'method': name,
+            'backend': self.backend_type,
+            'params': {'args': args, 'kwargs': kwargs}
+        }
+        return _remote_call(
+            self.url, payload, EXCEPTIONS_MAP, self._session_factory())
+
+
+class ServiceConnection(object):
+    def __init__(self, server_and_port, backend_endpoint, session_factory):
+        self.url = urlparse.urljoin(
+            'http://%s' % server_and_port, backend_endpoint)
+        self._session_factory = session_factory
+
+    def __getattr__(self, name):
+        def f(*args, **kwargs):
+            return self._call(name, *args, **kwargs)
+
+        return f
+
+    @exceptions.map_vcs_exceptions
+    def _call(self, name, *args, **kwargs):
+        payload = {
+            'id': str(uuid.uuid4()),
+            'method': name,
             'params': {'args': args, 'kwargs': kwargs}
         }
         return _remote_call(
@@ -178,7 +203,12 b' def _remote_call(url, payload, exception'
     except pycurl.error as e:
         raise exceptions.HttpVCSCommunicationError(e)
 
-    response = msgpack.unpackb(response.content)
+    try:
+        response = msgpack.unpackb(response.content)
+    except Exception:
+        log.exception('Failed to decode repsponse %r', response.content)
+        raise
+
     error = response.get('error')
     if error:
         type_ = error.get('type', 'Exception')

rhodecode/lib/vcs/connection.py

@@ -25,9 +25,13 b' Holds connection for remote server.'
 
 def _not_initialized(*args, **kwargs):
     """Placeholder for objects which have to be initialized first."""
-    raise Exception("rhodecode.lib.vcs is not yet initialized")
+    raise Exception(
+        "rhodecode.lib.vcs is not yet initialized. "
+        "Make sure `vcs.server` is enabled in your configuration.")
 
 # TODO: figure out a nice default value for these things
+Service = _not_initialized
+
 Git = _not_initialized
 Hg = _not_initialized
 Svn = _not_initialized

rhodecode/lib/vcs/exceptions.py

@@ -24,8 +24,7 b' Custom vcs exceptions module.'
 
 import functools
 import urllib2
-import pycurl
-from Pyro4.errors import CommunicationError
+
 
 class VCSCommunicationError(Exception):
     pass
@@ -129,6 +128,14 b' class NodeAlreadyRemovedError(Committing'
     pass
 
 
+class SubrepoMergeError(RepositoryError):
+    """
+    This happens if we try to merge a repository which contains subrepos and
+    the subrepos cannot be merged. The subrepos are not merged itself but
+    their references in the root repo are merged.
+    """
+
+
 class ImproperArchiveTypeError(VCSError):
     pass
 
@@ -157,6 +164,7 b' class UnhandledException(VCSError):'
     # TODO: johbo: Define our own exception for this and stop abusing
     # urllib's exception class.
     'url_error': urllib2.URLError,
+    'subrepo_merge_error': SubrepoMergeError,
 }
 
 

rhodecode/login/views.py

@@ -18,6 +18,7 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import collections
 import datetime
 import formencode
 import logging
@@ -30,6 +31,7 b' from recaptcha.client.captcha import sub'
 
 from rhodecode.authentication.base import authenticate, HTTP_TYPE
 from rhodecode.events import UserRegistered
+from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     AuthUser, HasPermissionAnyDecorator, CSRFRequired)
 from rhodecode.lib.base import get_ip_addr
@@ -46,6 +48,9 b' from rhodecode.translation import _'
 
 log = logging.getLogger(__name__)
 
+CaptchaData = collections.namedtuple(
+    'CaptchaData', 'active, private_key, public_key')
+
 
 def _store_user_in_session(session, username, remember=False):
     user = User.get_by_username(username, case_insensitive=True)
@@ -112,6 +117,14 b' class LoginView(object):'
             'errors': {},
         }
 
+    def _get_captcha_data(self):
+        settings = SettingsModel().get_all_settings()
+        private_key = settings.get('rhodecode_captcha_private_key')
+        public_key = settings.get('rhodecode_captcha_public_key')
+        active = bool(private_key)
+        return CaptchaData(
+            active=active, private_key=private_key, public_key=public_key)
+
     @view_config(
         route_name='login', request_method='GET',
         renderer='rhodecode:templates/login.html')
@@ -159,7 +172,7 b' class LoginView(object):'
         except formencode.Invalid as errors:
             defaults = errors.value
             # remove password from filling in form again
-            del defaults['password']
+            defaults.pop('password', None)
             render_ctx = self._get_template_context()
             render_ctx.update({
                 'errors': errors.error_dict,
@@ -191,10 +204,8 b' class LoginView(object):'
         errors = errors or {}
 
         settings = SettingsModel().get_all_settings()
-        captcha_public_key = settings.get('rhodecode_captcha_public_key')
-        captcha_private_key = settings.get('rhodecode_captcha_private_key')
-        captcha_active = bool(captcha_private_key)
         register_message = settings.get('rhodecode_register_message') or ''
+        captcha = self._get_captcha_data()
         auto_active = 'hg.register.auto_activate' in User.get_default_user()\
             .AuthUser.permissions['global']
 
@@ -203,8 +214,8 b' class LoginView(object):'
             'defaults': defaults,
             'errors': errors,
             'auto_active': auto_active,
-            'captcha_active': captcha_active,
-            'captcha_public_key': captcha_public_key,
+            'captcha_active': captcha.active,
+            'captcha_public_key': captcha.public_key,
             'register_message': register_message,
         })
         return render_ctx
@@ -215,9 +226,7 b' class LoginView(object):'
         route_name='register', request_method='POST',
         renderer='rhodecode:templates/register.html')
     def register_post(self):
-        captcha_private_key = SettingsModel().get_setting_by_name(
-            'rhodecode_captcha_private_key')
-        captcha_active = bool(captcha_private_key)
+        captcha = self._get_captcha_data()
         auto_active = 'hg.register.auto_activate' in User.get_default_user()\
             .AuthUser.permissions['global']
 
@@ -226,15 +235,15 b' class LoginView(object):'
             form_result = register_form.to_python(self.request.params)
             form_result['active'] = auto_active
 
-            if captcha_active:
+            if captcha.active:
                 response = submit(
                     self.request.params.get('recaptcha_challenge_field'),
                     self.request.params.get('recaptcha_response_field'),
-                    private_key=captcha_private_key,
+                    private_key=captcha.private_key,
                     remoteip=get_ip_addr(self.request.environ))
-                if captcha_active and not response.is_valid:
+                if not response.is_valid:
                     _value = form_result
-                    _msg = _('bad captcha')
+                    _msg = _('Bad captcha')
                     error_dict = {'recaptcha_field': _msg}
                     raise formencode.Invalid(_msg, _value, None,
                                              error_dict=error_dict)
@@ -251,8 +260,8 b' class LoginView(object):'
             raise HTTPFound(redirect_ro)
 
         except formencode.Invalid as errors:
-            del errors.value['password']
-            del errors.value['password_confirmation']
+            errors.value.pop('password', None)
+            errors.value.pop('password_confirmation', None)
             return self.register(
                 defaults=errors.value, errors=errors.error_dict)
 
@@ -268,14 +277,11 b' class LoginView(object):'
         route_name='reset_password', request_method=('GET', 'POST'),
         renderer='rhodecode:templates/password_reset.html')
     def password_reset(self):
-        settings = SettingsModel().get_all_settings()
-        captcha_private_key = settings.get('rhodecode_captcha_private_key')
-        captcha_active = bool(captcha_private_key)
-        captcha_public_key = settings.get('rhodecode_captcha_public_key')
+        captcha = self._get_captcha_data()
 
         render_ctx = {
-            'captcha_active': captcha_active,
-            'captcha_public_key': captcha_public_key,
+            'captcha_active': captcha.active,
+            'captcha_public_key': captcha.public_key,
             'defaults': {},
             'errors': {},
         }
@@ -285,15 +291,21 b' class LoginView(object):'
             try:
                 form_result = password_reset_form.to_python(
                     self.request.params)
-                if captcha_active:
+                if h.HasPermissionAny('hg.password_reset.disabled')():
+                    log.error('Failed attempt to reset password for %s.', form_result['email'] )
+                    self.session.flash(
+                        _('Password reset has been disabled.'),
+                        queue='error')
+                    return HTTPFound(self.request.route_path('reset_password'))
+                if captcha.active:
                     response = submit(
                         self.request.params.get('recaptcha_challenge_field'),
                         self.request.params.get('recaptcha_response_field'),
-                        private_key=captcha_private_key,
+                        private_key=captcha.private_key,
                         remoteip=get_ip_addr(self.request.environ))
-                    if captcha_active and not response.is_valid:
+                    if not response.is_valid:
                         _value = form_result
-                        _msg = _('bad captcha')
+                        _msg = _('Bad captcha')
                         error_dict = {'recaptcha_field': _msg}
                         raise formencode.Invalid(_msg, _value, None,
                                                  error_dict=error_dict)

rhodecode/model/changeset_status.py

@@ -80,7 +80,7 b' class ChangesetStatusModel(BaseModel):'
         """
         votes = defaultdict(int)
         reviewers_number = len(statuses_by_reviewers)
-        for user, statuses in statuses_by_reviewers:
+        for user, reasons, statuses in statuses_by_reviewers:
             if statuses:
                 ver, latest = statuses[0]
                 votes[latest.status] += 1
@@ -254,7 +254,7 b' class ChangesetStatusModel(BaseModel):'
                       for x, y in (itertools.groupby(sorted(st, key=version),
                                                      version))]
 
-            pull_request_reviewers.append([o.user, st])
+            pull_request_reviewers.append((o.user, o.reasons, st))
         return pull_request_reviewers
 
     def calculated_review_status(self, pull_request, reviewers_statuses=None):

rhodecode/model/db.py

@@ -22,8 +22,8 b''
 Database Models for RhodeCode Enterprise
 """
 
+import re
 import os
-import sys
 import time
 import hashlib
 import logging
@@ -36,28 +36,25 b' import collections'
 
 
 from sqlalchemy import *
-from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import (
     relationship, joinedload, class_mapper, validates, aliased)
 from sqlalchemy.sql.expression import true
-from beaker.cache import cache_region, region_invalidate
+from beaker.cache import cache_region
 from webob.exc import HTTPNotFound
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from pylons import url
 from pylons.i18n.translation import lazy_ugettext as _
 
-from rhodecode.lib.vcs import get_backend, get_vcs_instance
-from rhodecode.lib.vcs.utils.helpers import get_scm
-from rhodecode.lib.vcs.exceptions import VCSError
-from rhodecode.lib.vcs.backends.base import (
-    EmptyCommit, Reference, MergeFailureReason)
+from rhodecode.lib.vcs import get_vcs_instance
+from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
 from rhodecode.lib.utils2 import (
-    str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,
-    time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict)
-from rhodecode.lib.jsonalchemy import MutationObj, JsonType, JSONDict
+    str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
+    time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
+    glob2re)
+from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.encrypt import AESCipher
@@ -1990,12 +1987,12 b' class Repository(Base, BaseModel):'
         custom_wire = {
             'cache': cache  # controls the vcs.remote cache
         }
-
         repo = get_vcs_instance(
             repo_path=safe_str(self.repo_full_path),
             config=config,
             with_wire=custom_wire,
-            create=False)
+            create=False,
+            _vcs_alias=self.repo_type)
 
         return repo
 
@@ -2031,6 +2028,7 b' class RepoGroup(Base, BaseModel):'
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
+    personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
     users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
@@ -2086,6 +2084,13 b' class RepoGroup(Base, BaseModel):'
         return gr.scalar()
 
     @classmethod
+    def get_user_personal_repo_group(cls, user_id):
+        user = User.get(user_id)
+        return cls.query()\
+            .filter(cls.personal == true())\
+            .filter(cls.user == user).scalar()
+
+    @classmethod
     def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
                             case_insensitive=True):
         q = RepoGroup.query()
@@ -2317,6 +2322,10 b' class Permission(Base, BaseModel):'
         ('hg.register.manual_activate', _('User Registration with manual account activation')),
         ('hg.register.auto_activate', _('User Registration with automatic account activation')),
 
+        ('hg.password_reset.enabled', _('Password reset enabled')),
+        ('hg.password_reset.hidden', _('Password reset hidden')),
+        ('hg.password_reset.disabled', _('Password reset disabled')),
+
         ('hg.extern_activate.manual', _('Manual activation of external account')),
         ('hg.extern_activate.auto', _('Automatic activation of external account')),
 
@@ -2335,6 +2344,7 b' class Permission(Base, BaseModel):'
         'hg.create.write_on_repogroup.true',
         'hg.fork.repository',
         'hg.register.manual_activate',
+        'hg.password_reset.enabled',
         'hg.extern_activate.auto',
         'hg.inherit_default_perms.true',
     ]
@@ -2919,6 +2929,10 b' class ChangesetComment(Base, BaseModel):'
             q = q.filter(cls.pull_request_id == pull_request_id)
         return q.all()
 
+    @property
+    def outdated(self):
+        return self.display_state == self.COMMENT_OUTDATED
+
     def render(self, mentions=False):
         from rhodecode.lib import helpers as h
         return h.render(self.text, renderer=self.renderer, mentions=mentions)
@@ -3031,6 +3045,7 b' class _PullRequestBase(BaseModel):'
             nullable=False)
 
     target_ref = Column('other_ref', Unicode(255), nullable=False)
+    _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
 
     # TODO: dan: rename column to last_merge_source_rev
     _last_merge_source_rev = Column(
@@ -3061,8 +3076,7 b' class _PullRequestBase(BaseModel):'
 
     @property
     def source_ref_parts(self):
-        refs = self.source_ref.split(':')
-        return Reference(refs[0], refs[1], refs[2])
+        return self.unicode_to_reference(self.source_ref)
 
     @declared_attr
     def target_repo(cls):
@@ -3072,8 +3086,36 b' class _PullRequestBase(BaseModel):'
 
     @property
     def target_ref_parts(self):
-        refs = self.target_ref.split(':')
-        return Reference(refs[0], refs[1], refs[2])
+        return self.unicode_to_reference(self.target_ref)
+
+    @property
+    def shadow_merge_ref(self):
+        return self.unicode_to_reference(self._shadow_merge_ref)
+
+    @shadow_merge_ref.setter
+    def shadow_merge_ref(self, ref):
+        self._shadow_merge_ref = self.reference_to_unicode(ref)
+
+    def unicode_to_reference(self, raw):
+        """
+        Convert a unicode (or string) to a reference object.
+        If unicode evaluates to False it returns None.
+        """
+        if raw:
+            refs = raw.split(':')
+            return Reference(*refs)
+        else:
+            return None
+
+    def reference_to_unicode(self, ref):
+        """
+        Convert a reference object to unicode.
+        If reference is None it returns None.
+        """
+        if ref:
+            return u':'.join(ref)
+        else:
+            return None
 
 
 class PullRequest(Base, _PullRequestBase):
@@ -3107,11 +3149,21 b' class PullRequest(Base, _PullRequestBase'
         from rhodecode.model.pull_request import PullRequestModel
         pull_request = self
         merge_status = PullRequestModel().merge_status(pull_request)
+
+        pull_request_url = url(
+            'pullrequest_show', repo_name=self.target_repo.repo_name,
+            pull_request_id=self.pull_request_id, qualified=True)
+
+        merge_data = {
+            'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
+            'reference': (
+                pull_request.shadow_merge_ref._asdict()
+                if pull_request.shadow_merge_ref else None),
+        }
+
         data = {
             'pull_request_id': pull_request.pull_request_id,
-            'url': url('pullrequest_show', repo_name=self.target_repo.repo_name,
-                                       pull_request_id=self.pull_request_id,
-                                       qualified=True),
+            'url': pull_request_url,
             'title': pull_request.title,
             'description': pull_request.description,
             'status': pull_request.status,
@@ -3141,15 +3193,17 b' class PullRequest(Base, _PullRequestBase'
                     'commit_id': pull_request.target_ref_parts.commit_id,
                 },
             },
+            'merge': merge_data,
             'author': pull_request.author.get_api_data(include_secrets=False,
                                                        details='basic'),
             'reviewers': [
                 {
                     'user': reviewer.get_api_data(include_secrets=False,
                                                   details='basic'),
+                    'reasons': reasons,
                     'review_status': st[0][1].status if st else 'not_reviewed',
                 }
-                for reviewer, st in pull_request.reviewers_statuses()
+                for reviewer, reasons, st in pull_request.reviewers_statuses()
             ]
         }
 
@@ -3161,14 +3215,10 b' class PullRequest(Base, _PullRequestBase'
         }
 
     def calculated_review_status(self):
-        # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
-        # because it's tricky on how to use ChangesetStatusModel from there
-        warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().calculated_review_status(self)
 
     def reviewers_statuses(self):
-        warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().reviewers_statuses(self)
 
@@ -3201,9 +3251,23 b' class PullRequestReviewers(Base, BaseMod'
          'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
     )
 
-    def __init__(self, user=None, pull_request=None):
+    def __init__(self, user=None, pull_request=None, reasons=None):
         self.user = user
         self.pull_request = pull_request
+        self.reasons = reasons or []
+
+    @hybrid_property
+    def reasons(self):
+        if not self._reasons:
+            return []
+        return self._reasons
+
+    @reasons.setter
+    def reasons(self, val):
+        val = val or []
+        if any(not isinstance(x, basestring) for x in val):
+            raise Exception('invalid reasons type, must be list of strings')
+        self._reasons = val
 
     pull_requests_reviewers_id = Column(
         'pull_requests_reviewers_id', Integer(), nullable=False,
@@ -3213,6 +3277,9 b' class PullRequestReviewers(Base, BaseMod'
         ForeignKey('pull_requests.pull_request_id'), nullable=False)
     user_id = Column(
         "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
+    _reasons = Column(
+        'reason', MutationList.as_mutable(
+            JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
 
     user = relationship('User')
     pull_request = relationship('PullRequest')
@@ -3514,3 +3581,125 b' class Integration(Base, BaseModel):'
 
     def __repr__(self):
         return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
+
+
+class RepoReviewRuleUser(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_user_id = Column(
+        'repo_review_rule_user_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
+        nullable=False)
+    user = relationship('User')
+
+
+class RepoReviewRuleUserGroup(Base, BaseModel):
+    __tablename__ = 'repo_review_rules_users_groups'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+    repo_review_rule_users_group_id = Column(
+        'repo_review_rule_users_group_id', Integer(), primary_key=True)
+    repo_review_rule_id = Column("repo_review_rule_id",
+        Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
+    users_group_id = Column("users_group_id", Integer(),
+        ForeignKey('users_groups.users_group_id'), nullable=False)
+    users_group = relationship('UserGroup')
+
+
+class RepoReviewRule(Base, BaseModel):
+    __tablename__ = 'repo_review_rules'
+    __table_args__ = (
+        {'extend_existing': True, 'mysql_engine': 'InnoDB',
+         'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
+    )
+
+    repo_review_rule_id = Column(
+        'repo_review_rule_id', Integer(), primary_key=True)
+    repo_id = Column(
+        "repo_id", Integer(), ForeignKey('repositories.repo_id'))
+    repo = relationship('Repository', backref='review_rules')
+
+    _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+    _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
+        default=u'*') # glob
+
+    use_authors_for_review = Column("use_authors_for_review", Boolean(),
+        nullable=False, default=False)
+    rule_users = relationship('RepoReviewRuleUser')
+    rule_user_groups = relationship('RepoReviewRuleUserGroup')
+
+    @hybrid_property
+    def branch_pattern(self):
+        return self._branch_pattern or '*'
+
+    def _validate_glob(self, value):
+        re.compile('^' + glob2re(value) + '$')
+
+    @branch_pattern.setter
+    def branch_pattern(self, value):
+        self._validate_glob(value)
+        self._branch_pattern = value or '*'
+
+    @hybrid_property
+    def file_pattern(self):
+        return self._file_pattern or '*'
+
+    @file_pattern.setter
+    def file_pattern(self, value):
+        self._validate_glob(value)
+        self._file_pattern = value or '*'
+
+    def matches(self, branch, files_changed):
+        """
+        Check if this review rule matches a branch/files in a pull request
+
+        :param branch: branch name for the commit
+        :param files_changed: list of file paths changed in the pull request
+        """
+
+        branch = branch or ''
+        files_changed = files_changed or []
+
+        branch_matches = True
+        if branch:
+            branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
+            branch_matches = bool(branch_regex.search(branch))
+
+        files_matches = True
+        if self.file_pattern != '*':
+            files_matches = False
+            file_regex = re.compile(glob2re(self.file_pattern))
+            for filename in files_changed:
+                if file_regex.search(filename):
+                    files_matches = True
+                    break
+
+        return branch_matches and files_matches
+
+    @property
+    def review_users(self):
+        """ Returns the users which this rule applies to """
+
+        users = set()
+        users |= set([
+            rule_user.user for rule_user in self.rule_users
+            if rule_user.user.active])
+        users |= set(
+            member.user
+            for rule_user_group in self.rule_user_groups
+            for member in rule_user_group.users_group.members
+            if member.user.active
+        )
+        return users
+
+    def __repr__(self):
+        return '<RepoReviewerRule(id=%r, repo=%r)>' % (
+            self.repo_review_rule_id, self.repo)

rhodecode/model/forms.py

@@ -143,10 +143,8 b' def UserForm(edit=False, available_langu'
     return _UserForm
 
 
-def UserGroupForm(edit=False, old_data=None, available_members=None,
-                  allow_disabled=False):
+def UserGroupForm(edit=False, old_data=None, allow_disabled=False):
     old_data = old_data or {}
-    available_members = available_members or []
 
     class _UserGroupForm(formencode.Schema):
         allow_extra_fields = True
@@ -162,10 +160,6 b' def UserGroupForm(edit=False, old_data=N'
         users_group_active = v.StringBoolean(if_missing=False)
 
         if edit:
-            users_group_members = v.OneOf(
-                available_members, hideList=False, testValueList=True,
-                if_missing=None, not_empty=False
-            )
             # this is user group owner
             user = All(
                 v.UnicodeString(not_empty=True),
@@ -347,6 +341,8 b' def ApplicationSettingsForm():'
         rhodecode_post_code = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_captcha_public_key = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_captcha_private_key = v.UnicodeString(strip=True, min=1, not_empty=False)
+        rhodecode_create_personal_repo_group = v.StringBoolean(if_missing=False)
+        rhodecode_personal_repo_group_pattern = v.UnicodeString(strip=True, min=1, not_empty=False)
 
     return _ApplicationSettingsForm
 
@@ -427,7 +423,8 b' def LabsSettingsForm():'
     return _LabSettingsForm
 
 
-def ApplicationPermissionsForm(register_choices, extern_activate_choices):
+def ApplicationPermissionsForm(
+        register_choices, password_reset_choices, extern_activate_choices):
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
@@ -435,6 +432,7 b' def ApplicationPermissionsForm(register_'
         anonymous = v.StringBoolean(if_missing=False)
         default_register = v.OneOf(register_choices)
         default_register_message = v.UnicodeString()
+        default_password_reset = v.OneOf(password_reset_choices)
         default_extern_activate = v.OneOf(extern_activate_choices)
 
     return _DefaultPermissionsForm
@@ -519,7 +517,12 b' def UserExtraIpForm():'
     return _UserExtraIpForm
 
 
+
 def PullRequestForm(repo_id):
+    class ReviewerForm(formencode.Schema):
+        user_id = v.Int(not_empty=True)
+        reasons = All()
+
     class _PullRequestForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
@@ -531,8 +534,7 b' def PullRequestForm(repo_id):'
         target_ref = v.UnicodeString(strip=True, required=True)
         revisions = All(#v.NotReviewedRevisions(repo_id)(),
                         v.UniqueList()(not_empty=True))
-        review_members = v.UniqueList(convert=int)(not_empty=True)
-
+        review_members = formencode.ForEach(ReviewerForm())
         pullrequest_title = v.UnicodeString(strip=True, required=True)
         pullrequest_desc = v.UnicodeString(strip=True, required=False)
 

rhodecode/model/permission.py

@@ -51,8 +51,8 b' class PermissionModel(BaseModel):'
         'default_user_group_create': None,
         'default_fork_create': None,
         'default_inherit_default_permissions': None,
-
         'default_register': None,
+        'default_password_reset': None,
         'default_extern_activate': None,
 
         # object permissions below
@@ -61,57 +61,63 b' class PermissionModel(BaseModel):'
         'default_user_group_perm': None,
     }
 
-    def set_global_permission_choices(self, c_obj, translator):
+    def set_global_permission_choices(self, c_obj, gettext_translator):
+
         c_obj.repo_perms_choices = [
-            ('repository.none', translator('None'),),
-            ('repository.read', translator('Read'),),
-            ('repository.write', translator('Write'),),
-            ('repository.admin', translator('Admin'),)]
+            ('repository.none', gettext_translator('None'),),
+            ('repository.read', gettext_translator('Read'),),
+            ('repository.write', gettext_translator('Write'),),
+            ('repository.admin', gettext_translator('Admin'),)]
 
         c_obj.group_perms_choices = [
-            ('group.none', translator('None'),),
-            ('group.read', translator('Read'),),
-            ('group.write', translator('Write'),),
-            ('group.admin', translator('Admin'),)]
+            ('group.none', gettext_translator('None'),),
+            ('group.read', gettext_translator('Read'),),
+            ('group.write', gettext_translator('Write'),),
+            ('group.admin', gettext_translator('Admin'),)]
 
         c_obj.user_group_perms_choices = [
-            ('usergroup.none', translator('None'),),
-            ('usergroup.read', translator('Read'),),
-            ('usergroup.write', translator('Write'),),
-            ('usergroup.admin', translator('Admin'),)]
+            ('usergroup.none', gettext_translator('None'),),
+            ('usergroup.read', gettext_translator('Read'),),
+            ('usergroup.write', gettext_translator('Write'),),
+            ('usergroup.admin', gettext_translator('Admin'),)]
 
         c_obj.register_choices = [
-            ('hg.register.none', translator('Disabled')),
-            ('hg.register.manual_activate', translator('Allowed with manual account activation')),
-            ('hg.register.auto_activate', translator('Allowed with automatic account activation')),]
+            ('hg.register.none', gettext_translator('Disabled')),
+            ('hg.register.manual_activate', gettext_translator('Allowed with manual account activation')),
+            ('hg.register.auto_activate', gettext_translator('Allowed with automatic account activation')),]
+
+        c_obj.password_reset_choices = [
+            ('hg.password_reset.enabled', gettext_translator('Allow password recovery')),
+            ('hg.password_reset.hidden', gettext_translator('Hide password recovery link')),
+            ('hg.password_reset.disabled', gettext_translator('Disable password recovery')),]
 
         c_obj.extern_activate_choices = [
-            ('hg.extern_activate.manual', translator('Manual activation of external account')),
-            ('hg.extern_activate.auto', translator('Automatic activation of external account')),]
+            ('hg.extern_activate.manual', gettext_translator('Manual activation of external account')),
+            ('hg.extern_activate.auto', gettext_translator('Automatic activation of external account')),]
 
         c_obj.repo_create_choices = [
-            ('hg.create.none', translator('Disabled')),
-            ('hg.create.repository', translator('Enabled'))]
+            ('hg.create.none', gettext_translator('Disabled')),
+            ('hg.create.repository', gettext_translator('Enabled'))]
 
         c_obj.repo_create_on_write_choices = [
-            ('hg.create.write_on_repogroup.false', translator('Disabled')),
-            ('hg.create.write_on_repogroup.true', translator('Enabled'))]
+            ('hg.create.write_on_repogroup.false', gettext_translator('Disabled')),
+            ('hg.create.write_on_repogroup.true', gettext_translator('Enabled'))]
 
         c_obj.user_group_create_choices = [
-            ('hg.usergroup.create.false', translator('Disabled')),
-            ('hg.usergroup.create.true', translator('Enabled'))]
+            ('hg.usergroup.create.false', gettext_translator('Disabled')),
+            ('hg.usergroup.create.true', gettext_translator('Enabled'))]
 
         c_obj.repo_group_create_choices = [
-            ('hg.repogroup.create.false', translator('Disabled')),
-            ('hg.repogroup.create.true', translator('Enabled'))]
+            ('hg.repogroup.create.false', gettext_translator('Disabled')),
+            ('hg.repogroup.create.true', gettext_translator('Enabled'))]
 
         c_obj.fork_choices = [
-            ('hg.fork.none', translator('Disabled')),
-            ('hg.fork.repository', translator('Enabled'))]
+            ('hg.fork.none', gettext_translator('Disabled')),
+            ('hg.fork.repository', gettext_translator('Enabled'))]
 
         c_obj.inherit_default_permission_choices = [
-            ('hg.inherit_default_perms.false', translator('Disabled')),
-            ('hg.inherit_default_perms.true', translator('Enabled'))]
+            ('hg.inherit_default_perms.false', gettext_translator('Disabled')),
+            ('hg.inherit_default_perms.true', gettext_translator('Enabled'))]
 
     def get_default_perms(self, object_perms, suffix):
         defaults = {}
@@ -149,6 +155,9 b' class PermissionModel(BaseModel):'
             if perm.permission.permission_name.startswith('hg.register.'):
                 defaults['default_register' + suffix] = perm.permission.permission_name
 
+            if perm.permission.permission_name.startswith('hg.password_reset.'):
+                defaults['default_password_reset' + suffix] = perm.permission.permission_name
+
             if perm.permission.permission_name.startswith('hg.extern_activate.'):
                 defaults['default_extern_activate' + suffix] = perm.permission.permission_name
 
@@ -182,6 +191,7 b' class PermissionModel(BaseModel):'
 
                 # application perms
                 'default_register': 'hg.register.',
+                'default_password_reset': 'hg.password_reset.',
                 'default_extern_activate': 'hg.extern_activate.',
 
                 # object permissions below
@@ -383,6 +393,7 b' class PermissionModel(BaseModel):'
                 'default_user_group_perm',
 
                 'default_register',
+                'default_password_reset',
                 'default_extern_activate'])
             self.sa.commit()
         except (DatabaseError,):
@@ -404,6 +415,7 b' class PermissionModel(BaseModel):'
                 'default_user_group_perm',
 
                 'default_register',
+                'default_password_reset',
                 'default_extern_activate'])
             self.sa.commit()
         except (DatabaseError,):
@@ -429,6 +441,7 b' class PermissionModel(BaseModel):'
                 'default_inherit_default_permissions',
 
                 'default_register',
+                'default_password_reset',
                 'default_extern_activate'])
 
             # overwrite default repo permissions

rhodecode/model/pull_request.py

@@ -27,9 +27,11 b' from collections import namedtuple'
 import json
 import logging
 import datetime
+import urllib
 
 from pylons.i18n.translation import _
 from pylons.i18n.translation import lazy_ugettext
+from sqlalchemy import or_
 
 from rhodecode.lib import helpers as h, hooks_utils, diffs
 from rhodecode.lib.compat import OrderedDict
@@ -39,7 +41,7 b' from rhodecode.lib.markup_renderer impor'
 from rhodecode.lib.utils import action_logger
 from rhodecode.lib.utils2 import safe_unicode, safe_str, md5_safe
 from rhodecode.lib.vcs.backends.base import (
-    Reference, MergeResponse, MergeFailureReason)
+    Reference, MergeResponse, MergeFailureReason, UpdateFailureReason)
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError)
@@ -59,6 +61,12 b' from rhodecode.model.settings import Vcs'
 log = logging.getLogger(__name__)
 
 
+# Data structure to hold the response data when updating commits during a pull
+# request update.
+UpdateResponse = namedtuple(
+    'UpdateResponse', 'executed, reason, new, old, changes')
+
+
 class PullRequestModel(BaseModel):
 
     cls = PullRequest
@@ -88,9 +96,37 b' class PullRequestModel(BaseModel):'
         MergeFailureReason.TARGET_IS_LOCKED: lazy_ugettext(
             'This pull request cannot be merged because the target repository'
             ' is locked.'),
-        MergeFailureReason.MISSING_COMMIT: lazy_ugettext(
+        MergeFailureReason._DEPRECATED_MISSING_COMMIT: lazy_ugettext(
             'This pull request cannot be merged because the target or the '
             'source reference is missing.'),
+        MergeFailureReason.MISSING_TARGET_REF: lazy_ugettext(
+            'This pull request cannot be merged because the target '
+            'reference is missing.'),
+        MergeFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
+            'This pull request cannot be merged because the source '
+            'reference is missing.'),
+        MergeFailureReason.SUBREPO_MERGE_FAILED: lazy_ugettext(
+            'This pull request cannot be merged because of conflicts related '
+            'to sub repositories.'),
+    }
+
+    UPDATE_STATUS_MESSAGES = {
+        UpdateFailureReason.NONE: lazy_ugettext(
+            'Pull request update successful.'),
+        UpdateFailureReason.UNKNOWN: lazy_ugettext(
+            'Pull request update failed because of an unknown error.'),
+        UpdateFailureReason.NO_CHANGE: lazy_ugettext(
+            'No update needed because the source reference is already '
+            'up to date.'),
+        UpdateFailureReason.WRONG_REF_TPYE: lazy_ugettext(
+            'Pull request cannot be updated because the reference type is '
+            'not supported for an update.'),
+        UpdateFailureReason.MISSING_TARGET_REF: lazy_ugettext(
+            'This pull request cannot be updated because the target '
+            'reference is missing.'),
+        UpdateFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
+            'This pull request cannot be updated because the source '
+            'reference is missing.'),
     }
 
     def __get_pull_request(self, pull_request):
@@ -116,6 +152,11 b' class PullRequestModel(BaseModel):'
         owner = user.user_id == pull_request.user_id
         return self.check_user_merge(pull_request, user, api) or owner
 
+    def check_user_delete(self, pull_request, user):
+        owner = user.user_id == pull_request.user_id
+        _perms = ('repository.admin')
+        return self._check_perms(_perms, pull_request, user) or owner
+
     def check_user_change_status(self, pull_request, user, api=False):
         reviewer = user.user_id in [x.user_id for x in
                                     pull_request.reviewers]
@@ -127,12 +168,16 b' class PullRequestModel(BaseModel):'
     def _prepare_get_all_query(self, repo_name, source=False, statuses=None,
                                opened_by=None, order_by=None,
                                order_dir='desc'):
-        repo = self._get_repo(repo_name)
+        repo = None
+        if repo_name:
+            repo = self._get_repo(repo_name)
+
         q = PullRequest.query()
+
         # source or target
-        if source:
+        if repo and source:
             q = q.filter(PullRequest.source_repo == repo)
-        else:
+        elif repo:
             q = q.filter(PullRequest.target_repo == repo)
 
         # closed,opened
@@ -147,7 +192,8 b' class PullRequestModel(BaseModel):'
             order_map = {
                 'name_raw': PullRequest.pull_request_id,
                 'title': PullRequest.title,
-                'updated_on_raw': PullRequest.updated_on
+                'updated_on_raw': PullRequest.updated_on,
+                'target_repo': PullRequest.target_repo_id
             }
             if order_dir == 'asc':
                 q = q.order_by(order_map[order_by].asc())
@@ -305,6 +351,59 b' class PullRequestModel(BaseModel):'
                 PullRequestReviewers.user_id == user_id).all()
         ]
 
+    def _prepare_participating_query(self, user_id=None, statuses=None,
+                                     order_by=None, order_dir='desc'):
+        q = PullRequest.query()
+        if user_id:
+            reviewers_subquery = Session().query(
+                PullRequestReviewers.pull_request_id).filter(
+                PullRequestReviewers.user_id == user_id).subquery()
+            user_filter= or_(
+                PullRequest.user_id == user_id,
+                PullRequest.pull_request_id.in_(reviewers_subquery)
+            )
+            q = PullRequest.query().filter(user_filter)
+
+        # closed,opened
+        if statuses:
+            q = q.filter(PullRequest.status.in_(statuses))
+
+        if order_by:
+            order_map = {
+                'name_raw': PullRequest.pull_request_id,
+                'title': PullRequest.title,
+                'updated_on_raw': PullRequest.updated_on,
+                'target_repo': PullRequest.target_repo_id
+            }
+            if order_dir == 'asc':
+                q = q.order_by(order_map[order_by].asc())
+            else:
+                q = q.order_by(order_map[order_by].desc())
+
+        return q
+
+    def count_im_participating_in(self, user_id=None, statuses=None):
+        q = self._prepare_participating_query(user_id, statuses=statuses)
+        return q.count()
+
+    def get_im_participating_in(
+            self, user_id=None, statuses=None, offset=0,
+            length=None, order_by=None, order_dir='desc'):
+        """
+        Get all Pull requests that i'm participating in, or i have opened
+        """
+
+        q = self._prepare_participating_query(
+            user_id, statuses=statuses, order_by=order_by,
+            order_dir=order_dir)
+
+        if length:
+            pull_requests = q.limit(length).offset(offset).all()
+        else:
+            pull_requests = q.all()
+
+        return pull_requests
+
     def get_versions(self, pull_request):
         """
         returns version of pull request sorted by ID descending
@@ -333,10 +432,18 b' class PullRequestModel(BaseModel):'
         Session().add(pull_request)
         Session().flush()
 
+        reviewer_ids = set()
         # members / reviewers
-        for user_id in set(reviewers):
+        for reviewer_object in reviewers:
+            if isinstance(reviewer_object, tuple):
+                user_id, reasons = reviewer_object
+            else:
+                user_id, reasons = reviewer_object, []
+
             user = self._get_user(user_id)
-            reviewer = PullRequestReviewers(user, pull_request)
+            reviewer_ids.add(user.user_id)
+
+            reviewer = PullRequestReviewers(user, pull_request, reasons)
             Session().add(reviewer)
 
         # Set approval status to "Under Review" for all commits which are
@@ -348,7 +455,7 b' class PullRequestModel(BaseModel):'
             pull_request=pull_request
         )
 
-        self.notify_reviewers(pull_request, reviewers)
+        self.notify_reviewers(pull_request, reviewer_ids)
         self._trigger_pull_request_hook(
             pull_request, created_by_user, 'create')
 
@@ -441,7 +548,7 b' class PullRequestModel(BaseModel):'
         return merge_state
 
     def _comment_and_close_pr(self, pull_request, user, merge_state):
-        pull_request.merge_rev = merge_state.merge_commit_id
+        pull_request.merge_rev = merge_state.merge_ref.commit_id
         pull_request.updated_on = datetime.datetime.now()
 
         ChangesetCommentsModel().create(
@@ -471,7 +578,6 b' class PullRequestModel(BaseModel):'
         and return the new pull request version and the list
         of commits processed by this update action
         """
-
         pull_request = self.__get_pull_request(pull_request)
         source_ref_type = pull_request.source_ref_parts.type
         source_ref_name = pull_request.source_ref_parts.name
@@ -481,13 +587,26 b' class PullRequestModel(BaseModel):'
             log.debug(
                 "Skipping update of pull request %s due to ref type: %s",
                 pull_request, source_ref_type)
-            return (None, None)
+            return UpdateResponse(
+                executed=False,
+                reason=UpdateFailureReason.WRONG_REF_TPYE,
+                old=pull_request, new=None, changes=None)
 
         source_repo = pull_request.source_repo.scm_instance()
-        source_commit = source_repo.get_commit(commit_id=source_ref_name)
+        try:
+            source_commit = source_repo.get_commit(commit_id=source_ref_name)
+        except CommitDoesNotExistError:
+            return UpdateResponse(
+                executed=False,
+                reason=UpdateFailureReason.MISSING_SOURCE_REF,
+                old=pull_request, new=None, changes=None)
+
         if source_ref_id == source_commit.raw_id:
             log.debug("Nothing changed in pull request %s", pull_request)
-            return (None, None)
+            return UpdateResponse(
+                executed=False,
+                reason=UpdateFailureReason.NO_CHANGE,
+                old=pull_request, new=None, changes=None)
 
         # Finally there is a need for an update
         pull_request_version = self._create_version_from_snapshot(pull_request)
@@ -498,10 +617,16 b' class PullRequestModel(BaseModel):'
         target_ref_id = pull_request.target_ref_parts.commit_id
         target_repo = pull_request.target_repo.scm_instance()
 
-        if target_ref_type in ('tag', 'branch', 'book'):
-            target_commit = target_repo.get_commit(target_ref_name)
-        else:
-            target_commit = target_repo.get_commit(target_ref_id)
+        try:
+            if target_ref_type in ('tag', 'branch', 'book'):
+                target_commit = target_repo.get_commit(target_ref_name)
+            else:
+                target_commit = target_repo.get_commit(target_ref_id)
+        except CommitDoesNotExistError:
+            return UpdateResponse(
+                executed=False,
+                reason=UpdateFailureReason.MISSING_TARGET_REF,
+                old=pull_request, new=None, changes=None)
 
         # re-compute commit ids
         old_commit_ids = set(pull_request.revisions)
@@ -570,7 +695,10 b' class PullRequestModel(BaseModel):'
         Session().commit()
         self._trigger_pull_request_hook(pull_request, pull_request.author,
                                         'update')
-        return (pull_request_version, changes)
+
+        return UpdateResponse(
+            executed=True, reason=UpdateFailureReason.NONE,
+            old=pull_request, new=pull_request_version, changes=changes)
 
     def _create_version_from_snapshot(self, pull_request):
         version = PullRequestVersion()
@@ -588,6 +716,7 b' class PullRequestModel(BaseModel):'
         version._last_merge_source_rev = pull_request._last_merge_source_rev
         version._last_merge_target_rev = pull_request._last_merge_target_rev
         version._last_merge_status = pull_request._last_merge_status
+        version.shadow_merge_ref = pull_request.shadow_merge_ref
         version.merge_rev = pull_request.merge_rev
 
         version.revisions = pull_request.revisions
@@ -711,8 +840,21 b' class PullRequestModel(BaseModel):'
         pull_request.updated_on = datetime.datetime.now()
         Session().add(pull_request)
 
-    def update_reviewers(self, pull_request, reviewers_ids):
-        reviewers_ids = set(reviewers_ids)
+    def update_reviewers(self, pull_request, reviewer_data):
+        """
+        Update the reviewers in the pull request
+
+        :param pull_request: the pr to update
+        :param reviewer_data: list of tuples [(user, ['reason1', 'reason2'])]
+        """
+
+        reviewers_reasons = {}
+        for user_id, reasons in reviewer_data:
+            if isinstance(user_id, (int, basestring)):
+                user_id = self._get_user(user_id).user_id
+            reviewers_reasons[user_id] = reasons
+
+        reviewers_ids = set(reviewers_reasons.keys())
         pull_request = self.__get_pull_request(pull_request)
         current_reviewers = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request ==
@@ -728,7 +870,8 b' class PullRequestModel(BaseModel):'
         for uid in ids_to_add:
             changed = True
             _usr = self._get_user(uid)
-            reviewer = PullRequestReviewers(_usr, pull_request)
+            reasons = reviewers_reasons[uid]
+            reviewer = PullRequestReviewers(_usr, pull_request, reasons)
             Session().add(reviewer)
 
         self.notify_reviewers(pull_request, ids_to_add)
@@ -753,6 +896,18 b' class PullRequestModel(BaseModel):'
                      pull_request_id=pull_request.pull_request_id,
                      qualified=True)
 
+    def get_shadow_clone_url(self, pull_request):
+        """
+        Returns qualified url pointing to the shadow repository. If this pull
+        request is closed there is no shadow repository and ``None`` will be
+        returned.
+        """
+        if pull_request.is_closed():
+            return None
+        else:
+            pr_url = urllib.unquote(self.get_url(pull_request))
+            return safe_unicode('{pr_url}/repository'.format(pr_url=pr_url))
+
     def notify_reviewers(self, pull_request, reviewers_ids):
         # notification to reviewers
         if not reviewers_ids:
@@ -881,6 +1036,7 b' class PullRequestModel(BaseModel):'
 
         try:
             resp = self._try_merge(pull_request)
+            log.debug("Merge response: %s", resp)
             status = resp.possible, self.merge_status_message(
                 resp.failure_reason)
         except NotImplementedError:
@@ -923,8 +1079,15 b' class PullRequestModel(BaseModel):'
             "Trying out if the pull request %s can be merged.",
             pull_request.pull_request_id)
         target_vcs = pull_request.target_repo.scm_instance()
-        target_ref = self._refresh_reference(
-            pull_request.target_ref_parts, target_vcs)
+
+        # Refresh the target reference.
+        try:
+            target_ref = self._refresh_reference(
+                pull_request.target_ref_parts, target_vcs)
+        except CommitDoesNotExistError:
+            merge_state = MergeResponse(
+                False, False, None, MergeFailureReason.MISSING_TARGET_REF)
+            return merge_state
 
         target_locked = pull_request.target_repo.locked
         if target_locked and target_locked[0]:
@@ -940,7 +1103,7 b' class PullRequestModel(BaseModel):'
                 _last_merge_status == MergeFailureReason.NONE
             merge_state = MergeResponse(
                 possible, False, None, pull_request._last_merge_status)
-        log.debug("Merge response: %s", merge_state)
+
         return merge_state
 
     def _refresh_reference(self, reference, vcs_repository):
@@ -969,13 +1132,13 b' class PullRequestModel(BaseModel):'
 
         # Do not store the response if there was an unknown error.
         if merge_state.failure_reason != MergeFailureReason.UNKNOWN:
-            pull_request._last_merge_source_rev = pull_request.\
-                source_ref_parts.commit_id
+            pull_request._last_merge_source_rev = \
+                pull_request.source_ref_parts.commit_id
             pull_request._last_merge_target_rev = target_reference.commit_id
-            pull_request._last_merge_status = (
-                merge_state.failure_reason)
+            pull_request._last_merge_status = merge_state.failure_reason
+            pull_request.shadow_merge_ref = merge_state.merge_ref
             Session().add(pull_request)
-            Session().flush()
+            Session().commit()
 
         return merge_state
 

rhodecode/model/repo.py

@@ -148,6 +148,7 b' class RepoModel(BaseModel):'
             qualified=True)
 
     def get_users(self, name_contains=None, limit=20, only_active=True):
+
         # TODO: mikhail: move this method to the UserModel.
         query = self.sa.query(User)
         if only_active:
@@ -171,8 +172,9 b' class RepoModel(BaseModel):'
                 'first_name': user.name,
                 'last_name': user.lastname,
                 'username': user.username,
-                'icon_link': h.gravatar_url(user.email, 14),
-                'value_display': h.person(user.email),
+                'email': user.email,
+                'icon_link': h.gravatar_url(user.email, 30),
+                'value_display': h.person(user),
                 'value': user.username,
                 'value_type': 'user',
                 'active': user.active,
@@ -252,9 +254,11 b' class RepoModel(BaseModel):'
 
         def desc(desc):
             if c.visual.stylify_metatags:
-                return h.urlify_text(h.escaped_stylize(h.truncate(desc, 60)))
+                desc = h.urlify_text(h.escaped_stylize(desc))
             else:
-                return h.urlify_text(h.html_escape(h.truncate(desc, 60)))
+                desc = h.urlify_text(h.html_escape(desc))
+
+            return _render('repo_desc', desc)
 
         def state(repo_state):
             return _render("repo_state", repo_state)
@@ -373,11 +377,11 b' class RepoModel(BaseModel):'
             log.debug('Updating repo %s with params:%s', cur_repo, kwargs)
 
             update_keys = [
-                (1, 'repo_enable_downloads'),
                 (1, 'repo_description'),
-                (1, 'repo_enable_locking'),
                 (1, 'repo_landing_rev'),
                 (1, 'repo_private'),
+                (1, 'repo_enable_downloads'),
+                (1, 'repo_enable_locking'),
                 (1, 'repo_enable_statistics'),
                 (0, 'clone_uri'),
                 (0, 'fork_id')

rhodecode/model/repo_group.py

@@ -23,13 +23,13 b''
 repo group model for RhodeCode
 """
 
-
+import os
 import datetime
 import itertools
 import logging
-import os
 import shutil
 import traceback
+import string
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
@@ -38,7 +38,7 b' from rhodecode.model import BaseModel'
 from rhodecode.model.db import (
     RepoGroup, UserRepoGroupToPerm, User, Permission, UserGroupRepoGroupToPerm,
     UserGroup, Repository)
-from rhodecode.model.settings import VcsSettingsModel
+from rhodecode.model.settings import VcsSettingsModel, SettingsModel
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.utils2 import action_logger_generic
 
@@ -48,7 +48,8 b' log = logging.getLogger(__name__)'
 class RepoGroupModel(BaseModel):
 
     cls = RepoGroup
-    PERSONAL_GROUP_DESC = '[personal] repo group: owner `%(username)s`'
+    PERSONAL_GROUP_DESC = 'personal repo group of user `%(username)s`'
+    PERSONAL_GROUP_PATTERN = '${username}'  # default
 
     def _get_user_group(self, users_group):
         return self._get_instance(UserGroup, users_group,
@@ -76,6 +77,39 b' class RepoGroupModel(BaseModel):'
                 "sql_cache_short", "get_repo_group_%s" % repo_group_name))
         return repo.scalar()
 
+    def get_default_create_personal_repo_group(self):
+        value = SettingsModel().get_setting_by_name(
+            'create_personal_repo_group')
+        return value.app_settings_value if value else None or False
+
+    def get_personal_group_name_pattern(self):
+        value = SettingsModel().get_setting_by_name(
+            'personal_repo_group_pattern')
+        val = value.app_settings_value if value else None
+        group_template = val or self.PERSONAL_GROUP_PATTERN
+
+        group_template = group_template.lstrip('/')
+        return group_template
+
+    def get_personal_group_name(self, user):
+        template = self.get_personal_group_name_pattern()
+        return string.Template(template).safe_substitute(
+            username=user.username,
+            user_id=user.user_id,
+        )
+
+    def create_personal_repo_group(self, user, commit_early=True):
+        desc = self.PERSONAL_GROUP_DESC % {'username': user.username}
+        personal_repo_group_name = self.get_personal_group_name(user)
+
+        # create a new one
+        RepoGroupModel().create(
+            group_name=personal_repo_group_name,
+            group_description=desc,
+            owner=user.username,
+            personal=True,
+            commit_early=commit_early)
+
     def _create_default_perms(self, new_group):
         # create default permission
         default_perm = 'group.read'
@@ -92,7 +126,8 b' class RepoGroupModel(BaseModel):'
         repo_group_to_perm.user_id = def_user.user_id
         return repo_group_to_perm
 
-    def _get_group_name_and_parent(self, group_name_full, repo_in_path=False):
+    def _get_group_name_and_parent(self, group_name_full, repo_in_path=False,
+                                   get_object=False):
         """
         Get's the group name and a parent group name from given group name.
         If repo_in_path is set to truth, we asume the full path also includes
@@ -114,9 +149,13 b' class RepoGroupModel(BaseModel):'
         if len(_parts) > 1:
             parent_repo_group_name = _parts[0]
 
+        parent_group = None
         if parent_repo_group_name:
             parent_group = RepoGroup.get_by_group_name(parent_repo_group_name)
 
+        if get_object:
+            return group_name_cleaned, parent_repo_group_name, parent_group
+
         return group_name_cleaned, parent_repo_group_name
 
     def check_exist_filesystem(self, group_name, exc_on_failure=True):
@@ -125,7 +164,8 b' class RepoGroupModel(BaseModel):'
 
         if os.path.isdir(create_path):
             if exc_on_failure:
-                raise Exception('That directory already exists !')
+                abs_create_path = os.path.abspath(create_path)
+                raise Exception('Directory `{}` already exists !'.format(abs_create_path))
             return False
         return True
 
@@ -191,7 +231,7 b' class RepoGroupModel(BaseModel):'
                 shutil.move(rm_path, os.path.join(self.repos_path, _d))
 
     def create(self, group_name, group_description, owner, just_db=False,
-               copy_permissions=False, commit_early=True):
+               copy_permissions=False, personal=None, commit_early=True):
 
         (group_name_cleaned,
          parent_group_name) = RepoGroupModel()._get_group_name_and_parent(group_name)
@@ -199,11 +239,18 b' class RepoGroupModel(BaseModel):'
         parent_group = None
         if parent_group_name:
             parent_group = self._get_repo_group(parent_group_name)
+            if not parent_group:
+                # we tried to create a nested group, but the parent is not
+                # existing
+                raise ValueError(
+                    'Parent group `%s` given in `%s` group name '
+                    'is not yet existing.' % (parent_group_name, group_name))
 
-        # becase we are doing a cleanup, we need to check if such directory
-        # already exists. If we don't do that we can accidentally delete existing
-        # directory via cleanup that can cause data issues, since delete does a
-        # folder rename to special syntax later cleanup functions can delete this
+        # because we are doing a cleanup, we need to check if such directory
+        # already exists. If we don't do that we can accidentally delete
+        # existing directory via cleanup that can cause data issues, since
+        # delete does a folder rename to special syntax later cleanup
+        # functions can delete this
         cleanup_group = self.check_exist_filesystem(group_name,
                                                     exc_on_failure=False)
         try:
@@ -213,6 +260,7 b' class RepoGroupModel(BaseModel):'
             new_repo_group.group_description = group_description or group_name
             new_repo_group.parent_group = parent_group
             new_repo_group.group_name = group_name
+            new_repo_group.personal = personal
 
             self.sa.add(new_repo_group)
 
@@ -614,11 +662,15 b' class RepoGroupModel(BaseModel):'
         def repo_group_lnk(repo_group_name):
             return _render('repo_group_name', repo_group_name)
 
-        def desc(desc):
+        def desc(desc, personal):
+            prefix = h.escaped_stylize(u'[personal] ') if personal else ''
+
             if c.visual.stylify_metatags:
-                return h.urlify_text(h.escaped_stylize(h.truncate(desc, 60)))
+                desc = h.urlify_text(prefix + h.escaped_stylize(desc))
             else:
-                return h.urlify_text(h.html_escape(h.truncate(desc, 60)))
+                desc = h.urlify_text(prefix + h.html_escape(desc))
+
+            return _render('repo_group_desc', desc)
 
         def repo_group_actions(repo_group_id, repo_group_name, gr_count):
             return _render(
@@ -637,7 +689,7 b' class RepoGroupModel(BaseModel):'
                 "menu": quick_menu(group.group_name),
                 "name": repo_group_lnk(group.group_name),
                 "name_raw": group.group_name,
-                "desc": desc(group.group_description),
+                "desc": desc(group.group_description, group.personal),
                 "top_level_repos": 0,
                 "owner": user_profile(group.user.username)
             }

rhodecode/model/scm.py

@@ -25,13 +25,11 b' Scm model for RhodeCode'
 import os.path
 import re
 import sys
-import time
 import traceback
 import logging
 import cStringIO
 import pkg_resources
 
-import pylons
 from pylons.i18n.translation import _
 from sqlalchemy import func
 from zope.cachedescriptors.property import Lazy as LazyProperty
@@ -50,12 +48,12 b' from rhodecode.lib.exceptions import Non'
 from rhodecode.lib import hooks_utils, caches
 from rhodecode.lib.utils import (
     get_filesystem_repos, action_logger, make_db_config)
-from rhodecode.lib.utils2 import (
-    safe_str, safe_unicode, get_server_url, md5)
+from rhodecode.lib.utils2 import (safe_str, safe_unicode)
+from rhodecode.lib.system_info import get_system_info
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     Repository, CacheKey, UserFollowing, UserLog, User, RepoGroup,
-    PullRequest, DbMigrateVersion)
+    PullRequest)
 from rhodecode.model.settings import VcsSettingsModel
 
 log = logging.getLogger(__name__)
@@ -764,11 +762,15 b' class ScmModel(BaseModel):'
         :param repo:
         """
 
-        hist_l = []
-        choices = []
         repo = self._get_repo(repo)
-        hist_l.append(['rev:tip', _('latest tip')])
-        choices.append('rev:tip')
+
+        hist_l = [
+            ['rev:tip', _('latest tip')]
+        ]
+        choices = [
+            'rev:tip'
+        ]
+
         if not repo:
             return choices, hist_l
 
@@ -882,197 +884,8 b' class ScmModel(BaseModel):'
             self.install_svn_hooks(repo)
 
     def get_server_info(self, environ=None):
-        import platform
-        import rhodecode
-        import pkg_resources
-        from rhodecode.model.meta import Base as sql_base, Session
-        from sqlalchemy.engine import url
-        from rhodecode.lib.base import get_server_ip_addr, get_server_port
-        from rhodecode.lib.vcs.backends.git import discover_git_version
-        from rhodecode.model.gist import GIST_STORE_LOC
-
-        try:
-            # cygwin cannot have yet psutil support.
-            import psutil
-        except ImportError:
-            psutil = None
-
-        environ = environ or {}
-        _NA = 'NOT AVAILABLE'
-        _memory = _NA
-        _uptime = _NA
-        _boot_time = _NA
-        _cpu = _NA
-        _disk = dict(percent=0, used=0, total=0, error='')
-        _load = {'1_min': _NA, '5_min': _NA, '15_min': _NA}
-
-        model = VcsSettingsModel()
-        storage_path = model.get_repos_location()
-        gist_storage_path = os.path.join(storage_path, GIST_STORE_LOC)
-        archive_storage_path = rhodecode.CONFIG.get('archive_cache_dir', '')
-        search_index_storage_path = rhodecode.CONFIG.get('search.location', '')
-
-        if psutil:
-            # disk storage
-            try:
-                _disk = dict(psutil.disk_usage(storage_path)._asdict())
-            except Exception as e:
-                log.exception('Failed to fetch disk info')
-                _disk = {'percent': 0, 'used': 0, 'total': 0, 'error': str(e)}
-
-            # memory
-            _memory = dict(psutil.virtual_memory()._asdict())
-            _memory['percent2'] = psutil._common.usage_percent(
-                (_memory['total'] - _memory['free']),
-                _memory['total'], 1)
-
-            # load averages
-            if hasattr(psutil.os, 'getloadavg'):
-                _load = dict(zip(
-                    ['1_min', '5_min', '15_min'], psutil.os.getloadavg()))
-            _uptime = time.time() - psutil.boot_time()
-            _boot_time = psutil.boot_time()
-            _cpu = psutil.cpu_percent(0.5)
-
-        mods = dict([(p.project_name, p.version)
-                     for p in pkg_resources.working_set])
-
-        def get_storage_size(storage_path):
-            sizes = []
-            for file_ in os.listdir(storage_path):
-                storage_file = os.path.join(storage_path, file_)
-                if os.path.isfile(storage_file):
-                    try:
-                        sizes.append(os.path.getsize(storage_file))
-                    except OSError:
-                        log.exception('Failed to get size of storage file %s',
-                                      storage_file)
-                        pass
-
-            return sum(sizes)
-
-        # archive cache storage
-        _disk_archive = {'percent': 0, 'used': 0, 'total': 0}
-        try:
-            archive_storage_path_exists = os.path.isdir(
-                archive_storage_path)
-            if archive_storage_path and archive_storage_path_exists:
-                used = get_storage_size(archive_storage_path)
-                _disk_archive.update({
-                    'used': used,
-                    'total': used,
-                })
-        except Exception as e:
-            log.exception('failed to fetch archive cache storage')
-            _disk_archive['error'] = str(e)
-
-        # search index storage
-        _disk_index = {'percent': 0, 'used': 0, 'total': 0}
-        try:
-            search_index_storage_path_exists = os.path.isdir(
-                search_index_storage_path)
-            if search_index_storage_path_exists:
-                used = get_storage_size(search_index_storage_path)
-                _disk_index.update({
-                    'percent': 100,
-                    'used': used,
-                    'total': used,
-                })
-        except Exception as e:
-            log.exception('failed to fetch search index storage')
-            _disk_index['error'] = str(e)
-
-        # gist storage
-        _disk_gist = {'percent': 0, 'used': 0, 'total': 0, 'items': 0}
-        try:
-            items_count = 0
-            used = 0
-            for root, dirs, files in os.walk(safe_str(gist_storage_path)):
-                if root == gist_storage_path:
-                    items_count = len(dirs)
-
-                for f in files:
-                    try:
-                        used += os.path.getsize(os.path.join(root, f))
-                    except OSError:
-                        pass
-            _disk_gist.update({
-                'percent': 100,
-                'used': used,
-                'total': used,
-                'items': items_count
-            })
-        except Exception as e:
-            log.exception('failed to fetch gist storage items')
-            _disk_gist['error'] = str(e)
-
-        # GIT info
-        git_ver = discover_git_version()
-
-        # SVN info
-        # TODO: johbo: Add discover_svn_version to replace this code.
-        try:
-            import svn.core
-            svn_ver = svn.core.SVN_VERSION
-        except ImportError:
-            svn_ver = None
-
-        # DB stuff
-        db_info = url.make_url(rhodecode.CONFIG['sqlalchemy.db1.url'])
-        db_type = db_info.__to_string__()
-        try:
-            engine = sql_base.metadata.bind
-            db_server_info = engine.dialect._get_server_version_info(
-                Session.connection(bind=engine))
-            db_version = '%s %s' % (db_info.drivername,
-                                    '.'.join(map(str, db_server_info)))
-        except Exception:
-            log.exception('failed to fetch db version')
-            db_version = '%s %s' % (db_info.drivername, '?')
-
-        db_migrate = DbMigrateVersion.query().filter(
-            DbMigrateVersion.repository_id == 'rhodecode_db_migrations').one()
-        db_migrate_version = db_migrate.version
-
-        info = {
-            'py_version': ' '.join(platform._sys_version()),
-            'py_path': sys.executable,
-            'py_modules': sorted(mods.items(), key=lambda k: k[0].lower()),
-
-            'platform': safe_unicode(platform.platform()),
-            'storage': storage_path,
-            'archive_storage': archive_storage_path,
-            'index_storage': search_index_storage_path,
-            'gist_storage': gist_storage_path,
-
-
-            'db_type': db_type,
-            'db_version': db_version,
-            'db_migrate_version': db_migrate_version,
-
-            'rhodecode_version': rhodecode.__version__,
-            'rhodecode_config_ini': rhodecode.CONFIG.get('__file__'),
-            'server_ip': '%s:%s' % (
-                get_server_ip_addr(environ, log_errors=False),
-                get_server_port(environ)
-            ),
-            'server_id': rhodecode.CONFIG.get('instance_id'),
-
-            'git_version': safe_unicode(git_ver),
-            'hg_version': mods.get('mercurial'),
-            'svn_version': svn_ver,
-
-            'uptime': _uptime,
-            'boot_time': _boot_time,
-            'load': _load,
-            'cpu': _cpu,
-            'memory': _memory,
-            'disk': _disk,
-            'disk_archive': _disk_archive,
-            'disk_gist': _disk_gist,
-            'disk_index': _disk_index,
-        }
-        return info
+        server_info = get_system_info(environ)
+        return server_info
 
 
 def _check_rhodecode_hook(hook_path):

rhodecode/model/user.py

@@ -35,7 +35,7 b' from sqlalchemy.sql.expression import tr'
 from rhodecode import events
 from rhodecode.lib.utils2 import (
     safe_unicode, get_current_rhodecode_user, action_logger_generic,
-    AttributeDict)
+    AttributeDict, str2bool)
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.model import BaseModel
 from rhodecode.model.auth_token import AuthTokenModel
@@ -104,12 +104,13 b' class UserModel(BaseModel):'
             'cur_user': cur_user
         }
 
+        if 'create_repo_group' in form_data:
+            user_data['create_repo_group'] = str2bool(
+                form_data.get('create_repo_group'))
+
         try:
-            if form_data.get('create_repo_group'):
-                user_data['create_repo_group'] = True
             if form_data.get('password_change'):
                 user_data['force_password_change'] = True
-
             return UserModel().create_or_update(**user_data)
         except Exception:
             log.error(traceback.format_exc())
@@ -177,7 +178,7 b' class UserModel(BaseModel):'
             self, username, password, email, firstname='', lastname='',
             active=True, admin=False, extern_type=None, extern_name=None,
             cur_user=None, plugin=None, force_password_change=False,
-            allow_to_create_user=True, create_repo_group=False,
+            allow_to_create_user=True, create_repo_group=None,
             updating_user_id=None, language=None, strict_creation_check=True):
         """
         Creates a new instance if not found, or updates current one
@@ -222,8 +223,8 b' class UserModel(BaseModel):'
             # in case it's a plugin we don't care
             if not plugin:
 
-                # first check if we gave crypted password back, and if it matches
-                # it's not password change
+                # first check if we gave crypted password back, and if it
+                # matches it's not password change
                 if new_user.password == password:
                     return False
 
@@ -233,6 +234,12 b' class UserModel(BaseModel):'
 
             return False
 
+        # read settings on default personal repo group creation
+        if create_repo_group is None:
+            default_create_repo_group = RepoGroupModel()\
+                .get_default_create_personal_repo_group()
+            create_repo_group = default_create_repo_group
+
         user_data = {
             'username': username,
             'password': password,
@@ -319,17 +326,16 b' class UserModel(BaseModel):'
             self.sa.add(new_user)
 
             if not edit and create_repo_group:
-                # create new group same as username, and make this user an owner
-                desc = RepoGroupModel.PERSONAL_GROUP_DESC % {'username': username}
-                RepoGroupModel().create(group_name=username,
-                                        group_description=desc,
-                                        owner=username, commit_early=False)
+                RepoGroupModel().create_personal_repo_group(
+                    new_user, commit_early=False)
+
             if not edit:
                 # add the RSS token
                 AuthTokenModel().create(username,
                                         description='Generated feed token',
                                         role=AuthTokenModel.cls.ROLE_FEED)
                 log_create_user(created_by=cur_user, **new_user.get_dict())
+                events.trigger(events.UserPostCreate(user_data))
             return new_user
         except (DatabaseError,):
             log.error(traceback.format_exc())

rhodecode/model/user_group.py

@@ -189,18 +189,15 b' class UserGroupModel(BaseModel):'
         self._log_user_changes('removed from', user_group, removed)
 
     def _clean_members_data(self, members_data):
-        # TODO: anderson: this should be in the form validation but I couldn't
-        # make it work there as it conflicts with the other validator
         if not members_data:
             members_data = []
 
-        if isinstance(members_data, basestring):
-            new_members = [members_data]
-        else:
-            new_members = members_data
-
-        new_members = [int(uid) for uid in new_members]
-        return new_members
+        members = []
+        for user in members_data:
+            uid = int(user['member_user_id'])
+            if uid not in members and user['type'] in ['new', 'existing']:
+                members.append(uid)
+        return members
 
     def update(self, user_group, form_data):
         user_group = self._get_user_group(user_group)

rhodecode/model/validation_schema/preparers.py

@@ -21,7 +21,6 b''
 import unicodedata
 
 
-
 def strip_preparer(value):
     """
     strips given values using .strip() function

rhodecode/model/validation_schema/schemas/gist_schema.py

@@ -23,7 +23,7 b' import os'
 import colander
 
 from rhodecode.translation import _
-from rhodecode.model.validation_schema import validators, preparers
+from rhodecode.model.validation_schema import preparers
 
 
 def nodes_to_sequence(nodes, colander_node=None):
@@ -181,5 +181,3 b' class GistSchema(colander.MappingSchema)'
         validator=colander.OneOf([Gist.GIST_PRIVATE, Gist.GIST_PUBLIC]))
 
     nodes = Nodes()
-
-

rhodecode/model/validation_schema/schemas/repo_group_schema.py

@@ -21,9 +21,220 b''
 
 import colander
 
-
+from rhodecode.translation import _
 from rhodecode.model.validation_schema import validators, preparers, types
 
 
+def get_group_and_repo(repo_name):
+    from rhodecode.model.repo_group import RepoGroupModel
+    return RepoGroupModel()._get_group_name_and_parent(
+        repo_name, get_object=True)
+
+
[e-mail]
+def deferred_can_write_to_group_validator(node, kw):
+    old_values = kw.get('old_values') or {}
+    request_user = kw.get('user')
+
+    def can_write_group_validator(node, value):
+        from rhodecode.lib.auth import (
+            HasPermissionAny, HasRepoGroupPermissionAny)
+        from rhodecode.model.repo_group import RepoGroupModel
+
+        messages = {
+            'invalid_parent_repo_group':
+                _(u"Parent repository group `{}` does not exist"),
+            # permissions denied we expose as not existing, to prevent
+            # resource discovery
+            'permission_denied_parent_group':
+                _(u"Parent repository group `{}` does not exist"),
+            'permission_denied_root':
+                _(u"You do not have the permission to store "
+                  u"repository groups in the root location.")
+        }
+
+        value = value['repo_group_name']
+        parent_group_name = value
+
+        is_root_location = value is types.RootLocation
+
+        # NOT initialized validators, we must call them
+        can_create_repo_groups_at_root = HasPermissionAny(
+            'hg.admin', 'hg.repogroup.create.true')
+
+        if is_root_location:
+            if can_create_repo_groups_at_root(user=request_user):
+                # we can create repo group inside tool-level. No more checks
+                # are required
+                return
+            else:
+                raise colander.Invalid(node, messages['permission_denied_root'])
+
+        # check if the parent repo group actually exists
+        parent_group = None
+        if parent_group_name:
+            parent_group = RepoGroupModel().get_by_group_name(parent_group_name)
+            if value and not parent_group:
+                raise colander.Invalid(
+                    node, messages['invalid_parent_repo_group'].format(
+                        parent_group_name))
+
+        # check if we have permissions to create new groups under
+        # parent repo group
+        # create repositories with write permission on group is set to true
+        create_on_write = HasPermissionAny(
+            'hg.create.write_on_repogroup.true')(user=request_user)
+
+        group_admin = HasRepoGroupPermissionAny('group.admin')(
+            parent_group_name, 'can write into group validator', user=request_user)
+        group_write = HasRepoGroupPermissionAny('group.write')(
+            parent_group_name, 'can write into group validator', user=request_user)
+
+        # creation by write access is currently disabled. Needs thinking if
+        # we want to allow this...
+        forbidden = not (group_admin or (group_write and create_on_write and 0))
+
+        if parent_group and forbidden:
+            msg = messages['permission_denied_parent_group'].format(
+                parent_group_name)
+            raise colander.Invalid(node, msg)
+
+    return can_write_group_validator
+
+
[e-mail]
+def deferred_repo_group_owner_validator(node, kw):
+
+    def repo_owner_validator(node, value):
+        from rhodecode.model.db import User
+        existing = User.get_by_username(value)
+        if not existing:
+            msg = _(u'Repo group owner with id `{}` does not exists').format(
+                value)
+            raise colander.Invalid(node, msg)
+
+    return repo_owner_validator
+
+
[e-mail]
+def deferred_unique_name_validator(node, kw):
+    request_user = kw.get('user')
+    old_values = kw.get('old_values') or {}
+
+    def unique_name_validator(node, value):
+        from rhodecode.model.db import Repository, RepoGroup
+        name_changed = value != old_values.get('group_name')
+
+        existing = Repository.get_by_repo_name(value)
+        if name_changed and existing:
+            msg = _(u'Repository with name `{}` already exists').format(value)
+            raise colander.Invalid(node, msg)
+
+        existing_group = RepoGroup.get_by_group_name(value)
+        if name_changed and existing_group:
+            msg = _(u'Repository group with name `{}` already exists').format(
+                value)
+            raise colander.Invalid(node, msg)
+    return unique_name_validator
+
+
[e-mail]
+def deferred_repo_group_name_validator(node, kw):
+    return validators.valid_name_validator
+
+
+class GroupType(colander.Mapping):
+    def _validate(self, node, value):
+        try:
+            return dict(repo_group_name=value)
+        except Exception as e:
+            raise colander.Invalid(
+                node, '"${val}" is not a mapping type: ${err}'.format(
+                    val=value, err=e))
+
+    def deserialize(self, node, cstruct):
+        if cstruct is colander.null:
+            return cstruct
+
+        appstruct = super(GroupType, self).deserialize(node, cstruct)
+        validated_name = appstruct['repo_group_name']
+
+        # inject group based on once deserialized data
+        (repo_group_name_without_group,
+         parent_group_name,
+         parent_group) = get_group_and_repo(validated_name)
+
+        appstruct['repo_group_name_without_group'] = repo_group_name_without_group
+        appstruct['repo_group_name'] = parent_group_name or types.RootLocation
+        if parent_group:
+            appstruct['repo_group_id'] = parent_group.group_id
+
+        return appstruct
+
+
+class GroupSchema(colander.SchemaNode):
+    schema_type = GroupType
+    validator = deferred_can_write_to_group_validator
+    missing = colander.null
+
+
+class RepoGroup(GroupSchema):
+    repo_group_name = colander.SchemaNode(
+        types.GroupNameType())
+    repo_group_id = colander.SchemaNode(
+        colander.String(), missing=None)
+    repo_group_name_without_group = colander.SchemaNode(
+        colander.String(), missing=None)
+
+
+class RepoGroupAccessSchema(colander.MappingSchema):
+    repo_group = RepoGroup()
+
+
+class RepoGroupNameUniqueSchema(colander.MappingSchema):
+    unique_repo_group_name = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_unique_name_validator)
+
+
 class RepoGroupSchema(colander.Schema):
-    group_name = colander.SchemaNode(types.GroupNameType())
+
+    repo_group_name = colander.SchemaNode(
+        types.GroupNameType(),
+        validator=deferred_repo_group_name_validator)
+
+    repo_group_owner = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_repo_group_owner_validator)
+
+    repo_group_description = colander.SchemaNode(
+        colander.String(), missing='')
+
+    repo_group_copy_permissions = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+
+    repo_group_enable_locking = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+
+    def deserialize(self, cstruct):
+        """
+        Custom deserialize that allows to chain validation, and verify
+        permissions, and as last step uniqueness
+        """
+
+        appstruct = super(RepoGroupSchema, self).deserialize(cstruct)
+        validated_name = appstruct['repo_group_name']
+
+        # second pass to validate permissions to repo_group
+        second = RepoGroupAccessSchema().bind(**self.bindings)
+        appstruct_second = second.deserialize({'repo_group': validated_name})
+        # save result
+        appstruct['repo_group'] = appstruct_second['repo_group']
+
+        # thirds to validate uniqueness
+        third = RepoGroupNameUniqueSchema().bind(**self.bindings)
+        third.deserialize({'unique_repo_group_name': validated_name})
+
+        return appstruct

rhodecode/model/validation_schema/schemas/repo_schema.py

@@ -20,8 +20,302 b''
 
 import colander
 
+from rhodecode.translation import _
 from rhodecode.model.validation_schema import validators, preparers, types
 
+DEFAULT_LANDING_REF = 'rev:tip'
+
+
+def get_group_and_repo(repo_name):
+    from rhodecode.model.repo_group import RepoGroupModel
+    return RepoGroupModel()._get_group_name_and_parent(
+        repo_name, get_object=True)
+
+
[e-mail]
+def deferred_repo_type_validator(node, kw):
+    options = kw.get('repo_type_options', [])
+    return colander.OneOf([x for x in options])
+
+
[e-mail]
+def deferred_repo_owner_validator(node, kw):
+
+    def repo_owner_validator(node, value):
+        from rhodecode.model.db import User
+        existing = User.get_by_username(value)
+        if not existing:
+            msg = _(u'Repo owner with id `{}` does not exists').format(value)
+            raise colander.Invalid(node, msg)
+
+    return repo_owner_validator
+
+
[e-mail]
+def deferred_landing_ref_validator(node, kw):
+    options = kw.get('repo_ref_options', [DEFAULT_LANDING_REF])
+    return colander.OneOf([x for x in options])
+
+
[e-mail]
+def deferred_fork_of_validator(node, kw):
+    old_values = kw.get('old_values') or {}
+
+    def fork_of_validator(node, value):
+        from rhodecode.model.db import Repository, RepoGroup
+        existing = Repository.get_by_repo_name(value)
+        if not existing:
+            msg = _(u'Fork with id `{}` does not exists').format(value)
+            raise colander.Invalid(node, msg)
+        elif old_values['repo_name'] == existing.repo_name:
+            msg = _(u'Cannot set fork of '
+                    u'parameter of this repository to itself').format(value)
+            raise colander.Invalid(node, msg)
+
+    return fork_of_validator
+
+
[e-mail]
+def deferred_can_write_to_group_validator(node, kw):
+    request_user = kw.get('user')
+    old_values = kw.get('old_values') or {}
+
+    def can_write_to_group_validator(node, value):
+        """
+        Checks if given repo path is writable by user. This includes checks if
+        user is allowed to create repositories under root path or under
+        repo group paths
+        """
+
+        from rhodecode.lib.auth import (
+            HasPermissionAny, HasRepoGroupPermissionAny)
+        from rhodecode.model.repo_group import RepoGroupModel
+
+        messages = {
+            'invalid_repo_group':
+                _(u"Repository group `{}` does not exist"),
+            # permissions denied we expose as not existing, to prevent
+            # resource discovery
+            'permission_denied':
+                _(u"Repository group `{}` does not exist"),
+            'permission_denied_root':
+                _(u"You do not have the permission to store "
+                  u"repositories in the root location.")
+        }
+
+        value = value['repo_group_name']
+
+        is_root_location = value is types.RootLocation
+        # NOT initialized validators, we must call them
+        can_create_repos_at_root = HasPermissionAny(
+            'hg.admin', 'hg.create.repository')
+
+        # if values is root location, we simply need to check if we can write
+        # to root location !
+        if is_root_location:
+            if can_create_repos_at_root(user=request_user):
+                # we can create repo group inside tool-level. No more checks
+                # are required
+                return
+            else:
+                # "fake" node name as repo_name, otherwise we oddly report
+                # the error as if it was coming form repo_group
+                # however repo_group is empty when using root location.
+                node.name = 'repo_name'
+                raise colander.Invalid(node, messages['permission_denied_root'])
+
+        # parent group not exists ? throw an error
+        repo_group = RepoGroupModel().get_by_group_name(value)
+        if value and not repo_group:
+            raise colander.Invalid(
+                node, messages['invalid_repo_group'].format(value))
+
+        gr_name = repo_group.group_name
+
+        # create repositories with write permission on group is set to true
+        create_on_write = HasPermissionAny(
+            'hg.create.write_on_repogroup.true')(user=request_user)
+
+        group_admin = HasRepoGroupPermissionAny('group.admin')(
+            gr_name, 'can write into group validator', user=request_user)
+        group_write = HasRepoGroupPermissionAny('group.write')(
+            gr_name, 'can write into group validator', user=request_user)
+
+        forbidden = not (group_admin or (group_write and create_on_write))
+
+        # TODO: handling of old values, and detecting no-change in path
+        # to skip permission checks in such cases. This only needs to be
+        # implemented if we use this schema in forms as well
+
+        # gid = (old_data['repo_group'].get('group_id')
+        #        if (old_data and 'repo_group' in old_data) else None)
+        # value_changed = gid != safe_int(value)
+        # new = not old_data
+
+        # do check if we changed the value, there's a case that someone got
+        # revoked write permissions to a repository, he still created, we
+        # don't need to check permission if he didn't change the value of
+        # groups in form box
+        # if value_changed or new:
+        #     # parent group need to be existing
+        # TODO: ENDS HERE
+
+        if repo_group and forbidden:
+            msg = messages['permission_denied'].format(value)
+            raise colander.Invalid(node, msg)
+
+    return can_write_to_group_validator
+
 
-class RepoSchema(colander.Schema):
-    repo_name = colander.SchemaNode(types.GroupNameType())
[e-mail]
+def deferred_unique_name_validator(node, kw):
+    request_user = kw.get('user')
+    old_values = kw.get('old_values') or {}
+
+    def unique_name_validator(node, value):
+        from rhodecode.model.db import Repository, RepoGroup
+        name_changed = value != old_values.get('repo_name')
+
+        existing = Repository.get_by_repo_name(value)
+        if name_changed and existing:
+            msg = _(u'Repository with name `{}` already exists').format(value)
+            raise colander.Invalid(node, msg)
+
+        existing_group = RepoGroup.get_by_group_name(value)
+        if name_changed and existing_group:
+            msg = _(u'Repository group with name `{}` already exists').format(
+                value)
+            raise colander.Invalid(node, msg)
+    return unique_name_validator
+
+
[e-mail]
+def deferred_repo_name_validator(node, kw):
+    return validators.valid_name_validator
+
+
+class GroupType(colander.Mapping):
+    def _validate(self, node, value):
+        try:
+            return dict(repo_group_name=value)
+        except Exception as e:
+            raise colander.Invalid(
+                node, '"${val}" is not a mapping type: ${err}'.format(
+                    val=value, err=e))
+
+    def deserialize(self, node, cstruct):
+        if cstruct is colander.null:
+            return cstruct
+
+        appstruct = super(GroupType, self).deserialize(node, cstruct)
+        validated_name = appstruct['repo_group_name']
+
+        # inject group based on once deserialized data
+        (repo_name_without_group,
+         parent_group_name,
+         parent_group) = get_group_and_repo(validated_name)
+
+        appstruct['repo_name_without_group'] = repo_name_without_group
+        appstruct['repo_group_name'] = parent_group_name or types.RootLocation
+        if parent_group:
+            appstruct['repo_group_id'] = parent_group.group_id
+
+        return appstruct
+
+
+class GroupSchema(colander.SchemaNode):
+    schema_type = GroupType
+    validator = deferred_can_write_to_group_validator
+    missing = colander.null
+
+
+class RepoGroup(GroupSchema):
+    repo_group_name = colander.SchemaNode(
+        types.GroupNameType())
+    repo_group_id = colander.SchemaNode(
+        colander.String(), missing=None)
+    repo_name_without_group = colander.SchemaNode(
+        colander.String(), missing=None)
+
+
+class RepoGroupAccessSchema(colander.MappingSchema):
+    repo_group = RepoGroup()
+
+
+class RepoNameUniqueSchema(colander.MappingSchema):
+    unique_repo_name = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_unique_name_validator)
+
+
+class RepoSchema(colander.MappingSchema):
+
+    repo_name = colander.SchemaNode(
+        types.RepoNameType(),
+        validator=deferred_repo_name_validator)
+
+    repo_type = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_repo_type_validator)
+
+    repo_owner = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_repo_owner_validator)
+
+    repo_description = colander.SchemaNode(
+        colander.String(), missing='')
+
+    repo_landing_commit_ref = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_landing_ref_validator,
+        preparers=[preparers.strip_preparer],
+        missing=DEFAULT_LANDING_REF)
+
+    repo_clone_uri = colander.SchemaNode(
+        colander.String(),
+        validator=colander.All(colander.Length(min=1)),
+        preparers=[preparers.strip_preparer],
+        missing='')
+
+    repo_fork_of = colander.SchemaNode(
+        colander.String(),
+        validator=deferred_fork_of_validator,
+        missing=None)
+
+    repo_private = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_copy_permissions = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_statistics = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_downloads = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+    repo_enable_locking = colander.SchemaNode(
+        types.StringBooleanType(),
+        missing=False)
+
+    def deserialize(self, cstruct):
+        """
+        Custom deserialize that allows to chain validation, and verify
+        permissions, and as last step uniqueness
+        """
+
+        # first pass, to validate given data
+        appstruct = super(RepoSchema, self).deserialize(cstruct)
+        validated_name = appstruct['repo_name']
+
+        # second pass to validate permissions to repo_group
+        second = RepoGroupAccessSchema().bind(**self.bindings)
+        appstruct_second = second.deserialize({'repo_group': validated_name})
+        # save result
+        appstruct['repo_group'] = appstruct_second['repo_group']
+
+        # thirds to validate uniqueness
+        third = RepoNameUniqueSchema().bind(**self.bindings)
+        third.deserialize({'unique_repo_name': validated_name})
+
+        return appstruct

rhodecode/model/validation_schema/schemas/search_schema.py

@@ -33,8 +33,7 b' class SearchParamsSchema(colander.Mappin'
     search_sort = colander.SchemaNode(
         colander.String(),
         missing='newfirst',
-        validator=colander.OneOf(
-            ['oldfirst', 'newfirst']))
+        validator=colander.OneOf(['oldfirst', 'newfirst']))
     page_limit = colander.SchemaNode(
         colander.Integer(),
         missing=10,

rhodecode/model/validation_schema/types.py

@@ -18,22 +18,105 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import re
+
 import colander
+from rhodecode.model.validation_schema import preparers
+from rhodecode.model.db import User, UserGroup
+
+
+class _RootLocation(object):
+    pass
+
+RootLocation = _RootLocation()
+
+
+def _normalize(seperator, path):
+
+    if not path:
+        return ''
+    elif path is colander.null:
+        return colander.null
+
+    parts = path.split(seperator)
 
-from rhodecode.model.db import User, UserGroup
+    def bad_parts(value):
+        if not value:
+            return False
+        if re.match(r'^[.]+$', value):
+            return False
+
+        return True
+
+    def slugify(value):
+        value = preparers.slugify_preparer(value)
+        value = re.sub(r'[.]{2,}', '.', value)
+        return value
+
+    clean_parts = [slugify(item) for item in parts if item]
+    path = filter(bad_parts, clean_parts)
+    return seperator.join(path)
+
+
+class RepoNameType(colander.String):
+    SEPARATOR = '/'
+
+    def deserialize(self, node, cstruct):
+        result = super(RepoNameType, self).deserialize(node, cstruct)
+        if cstruct is colander.null:
+            return colander.null
+        return self._normalize(result)
+
+    def _normalize(self, path):
+        return _normalize(self.SEPARATOR, path)
 
 
 class GroupNameType(colander.String):
     SEPARATOR = '/'
 
     def deserialize(self, node, cstruct):
+        if cstruct is RootLocation:
+            return cstruct
+
         result = super(GroupNameType, self).deserialize(node, cstruct)
-        return self._replace_extra_slashes(result)
+        if cstruct is colander.null:
+            return colander.null
+        return self._normalize(result)
+
+    def _normalize(self, path):
+        return _normalize(self.SEPARATOR, path)
+
+
+class StringBooleanType(colander.String):
+    true_values = ['true', 't', 'yes', 'y', 'on', '1']
+    false_values = ['false', 'f', 'no', 'n', 'off', '0']
 
-    def _replace_extra_slashes(self, path):
-        path = path.split(self.SEPARATOR)
-        path = [item for item in path if item]
-        return self.SEPARATOR.join(path)
+    def serialize(self, node, appstruct):
+        if appstruct is colander.null:
+            return colander.null
+        if not isinstance(appstruct, bool):
+            raise colander.Invalid(node, '%r is not a boolean' % appstruct)
+
+        return appstruct and 'true' or 'false'
+
+    def deserialize(self, node, cstruct):
+        if cstruct is colander.null:
+            return colander.null
+
+        if isinstance(cstruct, bool):
+            return cstruct
+
+        if not isinstance(cstruct, basestring):
+            raise colander.Invalid(node, '%r is not a string' % cstruct)
+
+        value = cstruct.lower()
+        if value in self.true_values:
+            return True
+        elif value in self.false_values:
+            return False
+        else:
+            raise colander.Invalid(
+                node, '{} value cannot be translated to bool'.format(value))
 
 
 class UserOrUserGroupType(colander.SchemaType):

rhodecode/model/validation_schema/validators.py

@@ -1,9 +1,11 b''
 import os
+import re
 
 import ipaddress
 import colander
 
 from rhodecode.translation import _
+from rhodecode.lib.utils2 import glob2re
 
 
 def ip_addr_validator(node, value):
@@ -13,3 +15,34 b' def ip_addr_validator(node, value):'
     except ValueError:
         msg = _(u'Please enter a valid IPv4 or IpV6 address')
         raise colander.Invalid(node, msg)
+
+
+class IpAddrValidator(object):
+    def __init__(self, strict=True):
+        self.strict = strict
+
+    def __call__(self, node, value):
+        try:
+            # this raises an ValueError if address is not IpV4 or IpV6
+            ipaddress.ip_network(value, strict=self.strict)
+        except ValueError:
+            msg = _(u'Please enter a valid IPv4 or IpV6 address')
+            raise colander.Invalid(node, msg)
+
+
+def glob_validator(node, value):
+    try:
+        re.compile('^' + glob2re(value) + '$')
+    except Exception:
+        msg = _(u'Invalid glob pattern')
+        raise colander.Invalid(node, msg)
+
+
+def valid_name_validator(node, value):
+    from rhodecode.model.validation_schema import types
+    if value is types.RootLocation:
+        return
+
+    msg = _('Name must start with a letter or number. Got `{}`').format(value)
+    if not re.match(r'^[a-zA-z0-9]{1,}', value):
+        raise colander.Invalid(node, msg)

rhodecode/public/css/bootstrap-variables.less

@@ -45,7 +45,8 b''
 @font-family-sans-serif:  "Helvetica Neue", Helvetica, Arial, sans-serif;
 @font-family-serif:       Georgia, "Times New Roman", Times, serif;
 //** Default monospace fonts for `<code>`, `<kbd>`, and `<pre>`.
-@font-family-monospace:   Menlo, Monaco, Consolas, "Courier New", monospace;
+@font-family-monospace:   Consolas, "Liberation Mono", Menlo, Monaco, Courier, monospace;
+
 @font-family-base:        @font-family-sans-serif;
 
 @font-size-base:          14px;

rhodecode/public/css/buttons.less

@@ -188,6 +188,14 b' input[type="button"] {'
     padding: @padding * 1.2;
 }
 
+.btn-group {
+    display: inline-block;
+    .btn {
+        float: left;
+        margin: 0 0 0 -1px;
+    }
+}
+
 .btn-link {
     background: transparent;
     border: none;
@@ -326,15 +334,15 b' input[type="submit"],'
 input[type="reset"] {
     &.btn-danger {
         &:extend(.btn-danger);
-    
+
         &:focus {
             outline: 0;
         }
-    
+
         &:hover {
             &:extend(.btn-danger:hover);
         }
-    
+
         &.btn-link {
             &:extend(.btn-link);
             color: @alert2;

rhodecode/public/css/code-block.less

@@ -391,6 +391,7 b' td.injected_diff{'
     div.code-body {
         max-width: 1124px;
         overflow-x: auto;
+        overflow-y: hidden;
         padding: 0;
     }
     div.diffblock {
@@ -505,20 +506,19 b' div.codeblock {'
 
         th,
         td {
-            padding: .5em !important;
-            border: @border-thickness solid @border-default-color !important;
+            padding: .5em;
+            border: @border-thickness solid @border-default-color;
         }
     }
 
     table {
-        width: 0 !important;
-        border: 0px !important;
+        border: 0px;
         margin: 0;
         letter-spacing: normal;
-    
-    
+
+
         td {
-            border: 0px !important;
+            border: 0px;
             vertical-align: top;
         }
     }
@@ -568,7 +568,7 b' div.annotatediv { margin-left: 2px; marg'
 .CodeMirror ::-moz-selection { background: @rchighlightblue; }
 
 .code { display: block; border:0px !important; }
-.code-highlight,
+.code-highlight, /* TODO: dan: merge codehilite into code-highlight */
 .codehilite {
     .hll { background-color: #ffffcc }
     .c { color: #408080; font-style: italic } /* Comment */
@@ -640,3 +640,537 b' pre.literal-block, .codehilite pre{'
     .border-radius(@border-radius);
     background-color: @grey7;
 }
+
+
+/* START NEW CODE BLOCK CSS */
+
+@cb-line-height: 18px;
+@cb-line-code-padding: 10px;
+@cb-text-padding: 5px;
+
+@pill-padding: 2px 7px;
+
+input.filediff-collapse-state {
+    display: none;
+
+    &:checked + .filediff { /* file diff is collapsed */
+        .cb {
+            display: none
+        }
+        .filediff-collapse-indicator {
+            border-width: 9px 0 9px 15.6px;
+            border-color: transparent transparent transparent #ccc;
+        }
+        .filediff-menu {
+            display: none;
+        }
+        margin: -1px 0 0 0;
+    }
+
+    &+ .filediff { /* file diff is expanded */
+        .filediff-collapse-indicator {
+            border-width: 15.6px 9px 0 9px;
+            border-color: #ccc transparent transparent transparent;
+        }
+        .filediff-menu {
+            display: block;
+        }
+        margin: 20px 0;
+        &:nth-child(2) {
+            margin: 0;
+        }
+    }
+}
+.cs_files {
+    clear: both;
+}
+
+.diffset-menu {
+    margin-bottom: 20px;
+}
+.diffset {
+    margin: 20px auto;
+    .diffset-heading {
+        border: 1px solid @grey5;
+        margin-bottom: -1px;
+        // margin-top: 20px;
+        h2 {
+            margin: 0;
+            line-height: 38px;
+            padding-left: 10px;
+        }
+        .btn {
+            margin: 0;
+        }
+        background: @grey6;
+        display: block;
+        padding: 5px;
+    }
+    .diffset-heading-warning {
+        background: @alert3-inner;
+        border: 1px solid @alert3;
+    }
+    &.diffset-comments-disabled {
+        .cb-comment-box-opener, .comment-inline-form, .cb-comment-add-button {
+            display: none !important;
+        }
+    }
+}
+
+.pill {
+    display: block;
+    float: left;
+    padding: @pill-padding;
+}
+.pill-group {
+    .pill {
+        opacity: .8;
+        &:first-child {
+            border-radius: @border-radius 0 0 @border-radius;
+        }
+        &:last-child {
+            border-radius: 0 @border-radius @border-radius 0;
+        }
+        &:only-child {
+            border-radius: @border-radius;
+        }
+    }
+}
+
+.filediff {
+    border: 1px solid @grey5;
+
+    /* START OVERRIDES */
+    .code-highlight {
+        border: none;  // TODO: remove this border from the global
+                       // .code-highlight, it doesn't belong there
+    }
+    label {
+        margin: 0; // TODO: remove this margin definition from global label
+                   // it doesn't belong there - if margin on labels
+                   // are needed for a form they should be defined
+                   // in the form's class
+    }
+    /* END OVERRIDES */
+
+    * {
+        box-sizing: border-box;
+    }
+    .filediff-anchor {
+        visibility: hidden;
+    }
+    &:hover {
+        .filediff-anchor {
+            visibility: visible;
+        }
+    }
+
+    .filediff-collapse-indicator {
+        width: 0;
+        height: 0;
+        border-style: solid;
+        float: left;
+        margin: 2px 2px 0 0;
+        cursor: pointer;
+    }
+
+    .filediff-heading {
+        background: @grey7;
+        cursor: pointer;
+        display: block;
+        padding: 5px 10px;
+    }
+    .filediff-heading:after {
+        content: "";
+        display: table;
+        clear: both;
+    }
+    .filediff-heading:hover {
+        background: #e1e9f4 !important;
+    }
+
+    .filediff-menu {
+        float: right;
+
+        &> a, &> span {
+            padding: 5px;
+            display: block;
+            float: left
+        }
+    }
+
+    .pill {
+        &[op="name"] {
+            background: none;
+            color: @grey2;
+            opacity: 1;
+            color: white;
+        }
+        &[op="limited"] {
+            background: @grey2;
+            color: white;
+        }
+        &[op="binary"] {
+            background: @color7;
+            color: white;
+        }
+        &[op="modified"] {
+            background: @alert1;
+            color: white;
+        }
+        &[op="renamed"] {
+            background: @color4;
+            color: white;
+        }
+        &[op="mode"] {
+            background: @grey3;
+            color: white;
+        }
+        &[op="symlink"] {
+            background: @color8;
+            color: white;
+        }
+
+        &[op="added"] { /* added lines */
+            background: @alert1;
+            color: white;
+        }
+        &[op="deleted"] { /* deleted lines */
+            background: @alert2;
+            color: white;
+        }
+
+        &[op="created"] { /* created file */
+            background: @alert1;
+            color: white;
+        }
+        &[op="removed"] { /* deleted file */
+            background: @color5;
+            color: white;
+        }
+    }
+
+    .filediff-collapse-button, .filediff-expand-button {
+        cursor: pointer;
+    }
+    .filediff-collapse-button {
+        display: inline;
+    }
+    .filediff-expand-button {
+        display: none;
+    }
+    .filediff-collapsed .filediff-collapse-button {
+        display: none;
+    }
+    .filediff-collapsed .filediff-expand-button {
+        display: inline;
+    }
+
+    @comment-padding: 5px;
+
+    /**** COMMENTS ****/
+
+    .filediff-menu {
+        .show-comment-button {
+            display: none;
+        }
+    }
+    &.hide-comments {
+        .inline-comments {
+            display: none;
+        }
+        .filediff-menu {
+            .show-comment-button {
+                display: inline;
+            }
+            .hide-comment-button {
+                display: none;
+            }
+        }
+    }
+
+    .hide-line-comments {
+        .inline-comments {
+            display: none;
+        }
+    }
+    .inline-comments {
+        border-radius: @border-radius;
+        background: @grey6;
+        .comment {
+            margin: 0;
+            border-radius: @border-radius;
+        }
+        .comment-outdated {
+            opacity: 0.5;
+        }
+        .comment-inline {
+            background: white;
+            padding: (@comment-padding + 3px) @comment-padding;
+            border: @comment-padding solid @grey6;
+
+            .text {
+                border: none;
+            }
+            .meta {
+                border-bottom: 1px solid @grey6;
+                padding-bottom: 10px;
+            }
+        }
+        .comment-selected {
+            border-left: 6px solid @comment-highlight-color;
+        }
+        .comment-inline-form {
+            padding: @comment-padding;
+            display: none;
+        }
+        .cb-comment-add-button {
+            margin: @comment-padding;
+        }
+         /* hide add comment button when form is open */
+        .comment-inline-form-open ~ .cb-comment-add-button {
+            display: none;
+        }
+        .comment-inline-form-open {
+            display: block;
+        }
+         /* hide add comment button when form but no comments */
+        .comment-inline-form:first-child + .cb-comment-add-button {
+            display: none;
+        }
+         /* hide add comment button when no comments or form */
+        .cb-comment-add-button:first-child {
+            display: none;
+        }
+         /* hide add comment button when only comment is being deleted */
+        .comment-deleting:first-child + .cb-comment-add-button {
+            display: none;
+        }
+    }
+    /**** END COMMENTS ****/
+
+}
+
+
+table.cb {
+    width: 100%;
+    border-collapse: collapse;
+
+    .cb-text {
+        padding: @cb-text-padding;
+    }
+    .cb-hunk {
+        padding: @cb-text-padding;
+    }
+    .cb-expand {
+        display: none;
+    }
+    .cb-collapse {
+        display: inline;
+    }
+    &.cb-collapsed {
+        .cb-line {
+            display: none;
+        }
+        .cb-expand {
+            display: inline;
+        }
+        .cb-collapse {
+            display: none;
+        }
+    }
+
+    /* intentionally general selector since .cb-line-selected must override it
+       and they both use !important since the td itself may have a random color
+       generated by annotation blocks. TLDR: if you change it, make sure
+       annotated block selection and line selection in file view still work */
+    .cb-line-fresh .cb-content {
+        background: white !important;
+    }
+    .cb-warning {
+        background: #fff4dd;
+    }
+
+    &.cb-diff-sideside {
+        td {
+            &.cb-content {
+                width: 50%;
+            }
+        }
+    }
+
+    tr {
+        &.cb-annotate {
+            border-top: 1px solid #eee;
+
+            &+ .cb-line {
+                border-top: 1px solid #eee;
+            }
+
+            &:first-child {
+                border-top: none;
+                &+ .cb-line {
+                    border-top: none;
+                }
+            }
+        }
+
+        &.cb-hunk {
+            font-family: @font-family-monospace;
+            color: rgba(0, 0, 0, 0.3);
+
+            td {
+                &:first-child {
+                    background: #edf2f9;
+                }
+                &:last-child {
+                    background: #f4f7fb;
+                }
+            }
+        }
+    }
+
+
+    td {
+        vertical-align: top;
+        padding: 0;
+
+        &.cb-content {
+            font-size: 12.35px;
+
+            &.cb-line-selected .cb-code {
+                background: @comment-highlight-color !important;
+            }
+
+            span.cb-code {
+                line-height: @cb-line-height;
+                padding-left: @cb-line-code-padding;
+                padding-right: @cb-line-code-padding;
+                display: block;
+                white-space: pre-wrap;
+                font-family: @font-family-monospace;
+                word-break: break-word;
+                .nonl {
+                    color: @color5;
+                }
+            }
+
+            &> button.cb-comment-box-opener {
+
+                padding: 2px 5px 1px 5px;
+                margin-left: 0px;
+                margin-top: -1px;
+
+                border-radius: @border-radius;
+                position: absolute;
+                display: none;
+            }
+            .cb-comment {
+                margin-top: 10px;
+                white-space: normal;
+            }
+        }
+        &:hover {
+            button.cb-comment-box-opener {
+                display: block;
+            }
+            &+ td button.cb-comment-box-opener {
+                display: block
+            }
+        }
+
+        &.cb-data {
+            text-align: right;
+            width: 30px;
+            font-family: @font-family-monospace;
+
+            .icon-comment {
+                cursor: pointer;
+            }
+            &.cb-line-selected > div {
+                display: block;
+                background: @comment-highlight-color !important;
+                line-height: @cb-line-height;
+                color: rgba(0, 0, 0, 0.3);
+            }
+        }
+
+        &.cb-lineno {
+            padding: 0;
+            width: 50px;
+            color: rgba(0, 0, 0, 0.3);
+            text-align: right;
+            border-right: 1px solid #eee;
+            font-family: @font-family-monospace;
+
+            a::before {
+                content: attr(data-line-no);
+            }
+            &.cb-line-selected a {
+                background: @comment-highlight-color !important;
+            }
+
+            a {
+                display: block;
+                padding-right: @cb-line-code-padding;
+                padding-left: @cb-line-code-padding;
+                line-height: @cb-line-height;
+                color: rgba(0, 0, 0, 0.3);
+            }
+        }
+
+        &.cb-empty {
+            background: @grey7;
+        }
+
+        ins {
+            color: black;
+            background: #a6f3a6;
+            text-decoration: none;
+        }
+        del {
+            color: black;
+            background: #f8cbcb;
+            text-decoration: none;
+        }
+        &.cb-addition {
+            background: #ecffec;
+
+            &.blob-lineno {
+                background: #ddffdd;
+            }
+        }
+        &.cb-deletion {
+            background: #ffecec;
+
+            &.blob-lineno {
+                background: #ffdddd;
+            }
+        }
+
+        &.cb-annotate-info {
+            width: 320px;
+            min-width: 320px;
+            max-width: 320px;
+            padding: 5px 2px;
+            font-size: 13px;
+
+            strong.cb-annotate-message {
+                padding: 5px 0;
+                white-space: pre-line;
+                display: inline-block;
+            }
+            .rc-user {
+                float: none;
+                padding: 0 6px 0 17px;
+                min-width: auto;
+                min-height: auto;
+            }
+        }
+
+        &.cb-annotate-revision {
+            cursor: pointer;
+            text-align: right;
+        }
+    }
+}

rhodecode/public/css/codemirror.less

@@ -379,6 +379,8 b' span.CodeMirror-selectedtext { backgroun'
 }
 
 .CodeMirror-hint-entry .gravatar {
+  height: @gravatar-size;
+  width: @gravatar-size;
   margin-right: 4px;
 }
 

rhodecode/public/css/deform.less

@@ -90,28 +90,50 b''
     height: 40px;
   }
 
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item label {
-      display: none;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item:first-child label {
-      display: block;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item .panel-heading {
-      display: none;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item.form-group {
-      margin: 0;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item .deform-seq-item-group .form-group {
-      width: 45%; padding: 0 2px; float: left; clear: none;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item .deform-seq-item-group > .panel {
-      padding: 0;
-      margin: 5px 0;
-      border: none;
-  }
-  .deform-two-field-sequence .deform-seq-container .deform-seq-item .deform-seq-item-group > .panel > .panel-body {
-      padding: 0;
+  .deform-full-field-sequence.control-inputs {
+     width: 100%;
   }
 
+  .deform-table-sequence {
+    .deform-seq-container {
+      .deform-seq-item {
+        margin: 0;
+        label {
+          display: none;
+        }
+        .panel-heading {
+          display: none;
+        }
+        .deform-seq-item-group > .panel {
+          padding: 0;
+          margin: 5px 0;
+          border: none;
+          &> .panel-body {
+            padding: 0;
+          }
+        }
+        &:first-child label {
+          display: block;
+        }
+      }
+    }
+  }
+  .deform-table-2-sequence {
+    .deform-seq-container {
+      .deform-seq-item {
+        .form-group {
+          width: 45% !important; padding: 0 2px; float: left; clear: none;
+        }
+      }
+    }
+  }
+  .deform-table-3-sequence {
+    .deform-seq-container {
+      .deform-seq-item {
+        .form-group {
+          width: 30% !important; padding: 0 2px; float: left; clear: none;
+        }
+      }
+    }
+  }
 }

rhodecode/public/css/helpers.less

@@ -13,6 +13,16 b' a { cursor: pointer; }'
     }
 }
 
+.clearinner:after { /* clears all floating divs inside a block */
+    content: "";
+    display: table;
+    clear: both;
+}
+
+.js-template { /* mark a template for javascript use */
+    display: none;
+}
+
 .linebreak {
     display: block;
 }

rhodecode/public/css/login.less

@@ -188,6 +188,10 b''
             line-height: 1.5em;
         }
     }
+
+    p.help-block {
+        margin-left: 0;
+    }
 }
 
 .user-menu.submenu {

rhodecode/public/css/main.less

@@ -142,6 +142,10 b' input.inline[type="file"] {'
         color: @grey2;
     }
 
+    .alert {
+        margin: @padding 0;
+    }
+
     .error-branding {
         font-family: @text-semibold;
         color: @grey4;
@@ -435,6 +439,23 b' ul.auth_plugins {'
 //--- MODULES ------------------//
 
 
+// Server Announcement
+#server-announcement {
+    width: 95%;
+    margin: @padding auto;
+    padding: @padding;
+    border-width: 2px;
+    border-style: solid;
+    .border-radius(2px);
+    font-family: @text-bold;
+
+    &.info    { border-color: @alert4; background-color: @alert4-inner; }
+    &.warning { border-color: @alert3; background-color: @alert3-inner; }
+    &.error   { border-color: @alert2; background-color: @alert2-inner; }
+    &.success { border-color: @alert1; background-color: @alert1-inner; }
+    &.neutral { border-color: @grey3; background-color: @grey6; }
+}
+
 // Fixed Sidebar Column
 .sidebar-col-wrapper {
     padding-left: @sidebar-all-width;
@@ -1173,6 +1194,8 b' table.integrations {'
 	}
 
 	img {
+        height: @gravatar-size;
+        width: @gravatar-size;
 		margin-right: 1em;
 	}
 
@@ -1261,6 +1284,9 b' table.integrations {'
     width: 100%;
     overflow: auto;
 }
+.reviewer_reason {
+    padding-left: 20px;
+}
 .reviewer_status {
     display: inline-block;
     vertical-align: top;
@@ -1317,6 +1343,11 b' table.integrations {'
 .pr-details-title {
     padding-bottom: 8px;
     border-bottom: @border-thickness solid @grey5;
+
+    .action_button.disabled {
+        color: @grey4;
+        cursor: inherit;
+    }
     .action_button {
         color: @rcblue;
     }
@@ -1332,7 +1363,34 b' table.integrations {'
     margin-top: 0;
     padding: 0;
     list-style: outside none none;
+
+    img {
+        height: @gravatar-size;
+        width: @gravatar-size;
+        margin-right: .5em;
+        margin-left: 3px;
+    }
+
+    .to-delete {
+        .user {
+          text-decoration: line-through;
+        }
+    }
 }
+
+// new entry in group_members
+.td-author-new-entry {
+  background-color: rgba(red(@alert1), green(@alert1), blue(@alert1), 0.3);
+}
+
+.usergroup_member_remove {
+    width: 16px;
+    margin-bottom: 10px;
+    padding: 0;
+    color: black !important;
+    cursor: pointer;
+}
+
 .reviewer_ac .ac-input {
     width: 92%;
     margin-bottom: 1em;

rhodecode/public/css/polymer.less

@@ -5,6 +5,7 b''
 @import 'variables';
 @import 'buttons';
 @import 'alerts';
+@import 'type';
 
 :root {
     --primary-color: @rcblue;

rhodecode/public/css/rcicons.less

@@ -1,10 +1,11 b''
 @font-face {
   font-family: 'rcicons';
-  src: url('../fonts/RCIcons/rcicons.eot?18742416');
-  src: url('../fonts/RCIcons/rcicons.eot?18742416#iefix') format('embedded-opentype'),
-       url('../fonts/RCIcons/rcicons.woff?18742416') format('woff'),
-       url('../fonts/RCIcons/rcicons.ttf?18742416') format('truetype'),
-       url('../fonts/RCIcons/rcicons.svg?18742416#rcicons') format('svg');
+  src: url('../fonts/RCIcons/rcicons.eot?88634534');
+  src: url('../fonts/RCIcons/rcicons.eot?88634534#iefix') format('embedded-opentype'),
+       url('../fonts/RCIcons/rcicons.woff2?88634534') format('woff2'),
+       url('../fonts/RCIcons/rcicons.woff?88634534') format('woff'),
+       url('../fonts/RCIcons/rcicons.ttf?88634534') format('truetype'),
+       url('../fonts/RCIcons/rcicons.svg?88634534#rcicons') format('svg');
   font-weight: normal;
   font-style: normal;
 }
@@ -14,7 +15,7 b''
 @media screen and (-webkit-min-device-pixel-ratio:0) {
   @font-face {
     font-family: 'rcicons';
-    src: url('../font/rcicons.svg?18742415#rcicons') format('svg');
+    src: url('../fonts/RCIcons/rcicons.svg?88634534#rcicons') format('svg');
   }
 }
 */
@@ -35,7 +36,7 b''
   /* For safety - reset parent styles, that can break glyph codes*/
   font-variant: normal;
   text-transform: none;
-     
+ 
   /* fix buttons height, for twitter bootstrap */
   line-height: 1em;
  
@@ -46,40 +47,44 b''
   /* you can be more comfortable with increased icons size */
   /* font-size: 120%; */
  
+  /* Font smoothing. That was taken from TWBS */
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+ 
   /* Uncomment for 3D effect */
   /* text-shadow: 1px 1px 1px rgba(127, 127, 127, 0.3); */
 }
  
-.icon-svn-transparent:before { content: '\e800'; } /* '' */
-.icon-hg-transparent:before { content: '\e801'; } /* '' */
-.icon-git-transparent:before { content: '\e802'; } /* '' */
-.icon-svn:before { content: '\e803'; } /* '' */
-.icon-hg:before { content: '\e804'; } /* '' */
-.icon-git:before { content: '\e805'; } /* '' */
-.icon-plus:before { content: '\e806'; } /* '' */
-.icon-minus:before { content: '\e807'; } /* '' */
-.icon-remove:before { content: '\e808'; } /* '' */
-.icon-bookmark:before { content: '\e809'; } /* '' */
-.icon-branch:before { content: '\e80a'; } /* '' */
-.icon-tag:before { content: '\e80b'; } /* '' */
-.icon-lock:before { content: '\e80c'; } /* '' */
-.icon-unlock:before { content: '\e80d'; } /* '' */
+ 
+.icon-git:before { content: '\e82a'; } /* '' */
+.icon-hg:before { content: '\e82d'; } /* '' */
+.icon-svn:before { content: '\e82e'; } /* '' */
+.icon-plus:before { content: '\e813'; } /* '' */
+.icon-minus:before { content: '\e814'; } /* '' */
+.icon-remove:before { content: '\e815'; } /* '' */
+.icon-bookmark:before { content: '\e803'; } /* '' */
+.icon-branch:before { content: '\e804'; } /* '' */
+.icon-merge:before { content: '\e833'; } /* '' */
+.icon-tag:before { content: '\e805'; } /* '' */
+.icon-lock:before { content: '\e806'; } /* '' */
+.icon-unlock:before { content: '\e807'; } /* '' */
 .icon-delete:before,
-.icon-false:before { content: '\e80e'; } /* '' */
+.icon-false:before { content: '\e800'; } /* '' */
 .icon-ok:before,
-.icon-true:before { content: '\e80f'; } /* '' */
-.icon-comment:before { content: '\e810'; } /* '' */
-.icon-feed:before { content: '\e811'; } /* '' */
-.icon-right:before { content: '\e812'; } /* '' */
-.icon-left:before { content: '\e813'; } /* '' */
-.icon-arrow_down:before { content: '\e814'; } /* '' */
-.icon-group:before { content: '\e815'; } /* '' */
-.icon-folder:before { content: '\e816'; } /* '' */
-.icon-fork:before { content: '\e817'; } /* '' */
-.icon-more:before { content: '\e818'; } /* '' */
-.icon-comment-add:before { content: '\e819'; } /* '' */
-
-
+.icon-true:before { content: '\e801'; } /* '' */
+.icon-feed:before { content: '\e808'; } /* '' */
+.icon-left:before { content: '\e809'; } /* '' */
+.icon-right:before { content: '\e80a'; } /* '' */
+.icon-arrow_down:before { content: '\e80b'; } /* '' */
+.icon-arrow_up:before { content: '\e832'; } /* '' */
+.icon-group:before { content: '\e80f'; } /* '' */
+.icon-folder:before { content: '\e810'; } /* '' */
+.icon-fork:before { content: '\e811'; } /* '' */
+.icon-more:before { content: '\e812'; } /* '' */
+.icon-comment:before { content: '\e802'; } /* '' */
+.icon-comment-add:before { content: '\e82f'; } /* '' */
+.icon-comment-toggle:before { content: '\e830'; } /* '' */
+.icon-rhodecode:before { content: '\e831'; } /* '' */
 .icon-remove-sign:before { &:extend(.icon-remove:before); } 
 .icon-repo-private:before,
 .icon-repo-lock:before { &:extend(.icon-lock:before); }

rhodecode/public/css/tables.less

@@ -129,6 +129,13 b' table.dataTable {'
 
         &.td-description {
             min-width: 350px;
+
+            &.truncate, .truncate-wrap {
+                white-space: nowrap;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                max-width: 450px;
+            }
         }
 
         &.td-componentname {

rhodecode/public/css/type.less

@@ -399,7 +399,6 b' dd {'
 .dl-horizontal {
 
     overflow: hidden;
-    margin-top: -5px;
     margin-bottom: @space;
 
     dt, dd {

rhodecode/public/fonts/RCIcons/rcicons.svg

@@ -6,32 +6,59 b''
 <font id="rcicons" horiz-adv-x="1000" >
 <font-face font-family="rcicons" font-weight="400" font-stretch="normal" units-per-em="1000" ascent="850" descent="-150" />
 <missing-glyph horiz-adv-x="1000" />
-<glyph glyph-name="rc-icon-svn-transparent" unicode="&#xe800;" d="m938 855h-871c-36 0-67-31-67-67v-871c0-36 31-67 67-67h871c36 0 67 31 67 67v871c0 36-31 67-67 67z m-5-936h-864v864h864v-864z m-762 312c8-2 15-5 22-7 7-3 14-3 21-3 15 0 29 3 41 8 12 4 21 12 31 21 9 10 14 19 19 31 5 12 7 24 7 36 0 9-2 16-5 24-2 7-7 11-9 16-5 5-10 10-15 12-4 2-12 5-16 7-5 3-12 5-17 7-5 3-9 5-14 8-5 2-7 4-10 9-2 2-5 7-5 12 0 5 0 9 3 12 2 5 2 7 7 9 2 3 7 5 10 8 4 2 9 2 14 2 5 0 12 0 14-2 5-3 7-5 12-5 2-3 7-5 10-5 2-2 4-2 7-2 2 0 4 0 7 2 2 2 5 2 7 7l17 24c-3 5-8 9-12 12-5 5-10 7-17 9-7 3-12 5-19 8-7 2-14 2-21 2-15 0-27-2-39-7s-21-12-28-19c-7-7-14-17-19-29-5-9-7-21-7-33 0-10 2-19 4-26 3-8 8-12 10-17 5-5 10-10 14-12 5-2 12-5 17-7 5-2 12-5 17-5 4-2 9-5 14-7s7-5 9-10c3-2 5-7 5-11 0-12-2-19-9-27-5-4-15-9-24-9-7 0-14 0-19 2-5 3-10 5-14 7-5 3-8 5-10 8-2 2-7 2-10 2-2 0-4 0-7-2-2-3-4-3-7-5l-21-31c5-5 9-10 14-14 7-5 14-8 21-10z m308-7l126 257h-48c-2 0-5 0-7 0-2 0-5-2-5-2-2 0-2-3-4-5-3-3-3-3-3-5l-59-143c-3-5-8-12-10-19-2-7-5-14-7-21 0 7-2 14-2 21-3 7-3 14-5 19l-26 143c0 5-3 7-5 10-3 2-7 2-12 2h-45l64-257h48z m207 150c0 2 0 5 0 9 0 3 0 8 0 10l90-160c3-2 5-4 7-7 3-2 8-2 12-2h31l31 257h-50l-16-145c0-3 0-7-3-10 0-5 0-7 0-12l-90 160c0 2-3 2-3 5s-4 0-4 0c-3 0-3 0-5 2-3 0-5 0-7 0h-31l-31-257h50l19 150z" horiz-adv-x="1000" />
-<glyph glyph-name="rc-icon-hg-transparent" unicode="&#xe801;" d="m933 850h-871c-36 0-67-31-67-67v-871c0-36 31-67 67-67h871c36 0 67 31 67 67v871c0 36-31 67-67 67z m-2-933h-864v864h864v-864z m-605 421h93l-14-109h57l31 257h-57l-15-110h-92l14 110h-57l-31-257h57l14 109z m238-88c10-9 22-19 34-24 14-5 28-9 43-9 9 0 19 0 26 2 9 0 16 2 24 5 7 2 14 5 21 9 7 3 14 8 21 12l15 107h-86l-5-31c0-2 0-4 3-7 2-2 4-2 7-2h21l-5-43c-4-2-9-5-16-5-5-2-12-2-19-2-10 0-17 2-24 5-7 2-14 7-19 14-5 7-10 14-12 24 2 7 2 16 2 28 0 15 3 29 5 41 5 12 10 21 17 31s14 14 24 19c9 5 19 7 30 7 5 0 10 0 15 0 5 0 7-2 12-2 4-3 7-3 12-5 4-3 7-5 11-7 5-3 10-5 12-3 5 0 8 3 12 7l19 24c-4 5-9 10-14 15-5 4-12 9-19 11-7 3-14 8-24 8-9 2-19 2-31 2-14 0-26-2-38-5-12-2-24-7-33-14-10-7-19-14-29-24-9-9-16-19-21-28-7-12-10-24-14-36-3-12-5-26-5-41 0-16 2-31 7-45 5-17 12-28 21-38z" horiz-adv-x="1000" />
-<glyph glyph-name="rc-icon-git-transparent" unicode="&#xe802;" d="m933 850h-885c-38 0-69-29-69-67v-866c0-36 31-67 66-67h886c38 0 67 31 67 67v866c2 38-29 67-65 67z m-4-931h-879v862h879v-862z m-269 307h57l26 212h67l7 45h-193l-5-45h67l-26-212z m-103 257h-59l-31-257h57l33 257z m-336-219c10-9 22-19 34-23 14-5 28-10 45-10 10 0 19 0 29 2 9 0 16 3 23 5 8 3 15 5 22 10 7 2 14 7 21 12l15 107h-89l-4-31c0-3 0-5 2-7s5-3 7-3h22l-5-43c-5-2-12-4-17-4-5-3-12-3-19-3-9 0-16 3-24 5-7 2-14 7-19 14-4 7-9 15-12 24-2 10-4 19-4 31 0 14 2 29 4 41 5 11 10 21 17 30 7 10 14 15 24 20 9 4 19 7 31 7 5 0 9 0 14 0 5 0 7-3 12-3 5-2 7-2 12-4 5-3 7-5 12-8 5-2 9-4 14-2 5 0 7 2 12 7l19 24c-5 5-9 9-14 14-5 5-12 7-19 12-7 3-15 7-24 7s-17-2-29-2c-14 0-26-2-38-5-12-2-24-7-33-14-10-7-19-14-29-22-9-9-16-19-21-28-7-12-12-24-14-36-3-12-5-26-5-40 0-17 2-31 7-46 5-16 12-28 21-38z" horiz-adv-x="1000" />
-<glyph glyph-name="svn" unicode="&#xe803;" d="m934 850h-868c-36 0-66-30-66-66v-868c0-36 30-66 66-66h868c36 0 66 30 66 66v868c0 36-30 66-66 66z m-779-445c4-4 8-7 13-10 5-2 11-6 18-9 7-2 14-5 22-7 7-3 13-6 21-10 7-4 14-9 19-14 5-6 10-12 13-20 4-7 5-17 5-29 0-16-2-31-8-45-5-13-14-26-24-37-10-10-23-19-38-25-15-6-31-9-50-9-8 0-18 1-27 3-9 2-19 5-26 8-10 2-18 7-25 12-8 5-14 11-19 17l26 33c3 2 5 5 8 6 2 1 6 2 8 2 4 0 8-1 13-3 4-3 9-7 12-10 5-4 10-7 17-10 6-3 13-4 22-4 14 0 24 4 31 11 8 8 12 18 12 33 0 6-2 12-5 16-4 4-8 7-13 11-5 3-11 5-19 8-7 2-13 5-21 7-7 3-14 6-21 9-8 4-13 9-19 14-5 6-10 12-12 21-4 9-5 19-5 31 0 14 2 28 7 41 5 13 13 25 23 35 10 10 22 18 36 24 14 6 30 9 47 9 9 0 18-1 27-3 8-2 16-5 23-7 8-4 14-8 20-13 7-5 12-10 15-15l-18-31c-3-4-5-6-8-7-2-2-5-3-9-3-3 0-6 1-10 4s-7 5-11 7c-4 3-9 5-14 8-5 2-11 4-18 4-7 0-13-2-18-3-5-2-9-5-12-7-4-4-7-8-8-12-4-6-5-11-5-17 0-5 3-10 5-14z m318-215h-65l-79 319h57c7 0 12-1 15-5 4-3 7-6 7-11l33-177c3-7 4-15 5-23 2-9 3-18 4-27 3 9 6 18 10 27 4 8 8 16 11 23l75 177c2 2 3 3 4 6 1 2 4 4 6 5 3 1 5 2 8 4 2 1 5 1 9 1h57l-157-319z m430 0h-38c-5 0-10 1-14 3-3 1-6 5-10 8l-111 197c0-4 0-8-1-12 0-3-1-7-1-11l-23-186h-62l40 319h37c3 0 6 0 8 0 2 0 3-2 5-2 1-1 2-2 3-3 2-2 3-4 4-7l111-197c0 5 2 10 2 15 0 5 1 9 1 14l21 180h63l-35-318z" horiz-adv-x="1000" />
-<glyph glyph-name="hg" unicode="&#xe804;" d="m935 851h-867c-37 0-67-30-67-66v-868c0-36 30-66 67-66h867c36 0 66 30 66 66v868c0 36-30 66-66 66z m-491-660h-71l16 135h-115l-16-135h-72l39 319h71l-16-135h115l16 135h72l-39-319z m180 104c4-11 9-20 15-29 6-7 14-13 22-17 9-4 19-6 29-6 9 0 16 1 24 2 7 1 14 4 20 6l6 53h-27c-4 0-8 1-10 4-3 2-3 5-3 8l5 39h106l-16-134c-9-6-16-11-25-15-9-3-17-7-27-10-10-2-20-5-30-6-10-1-22-2-34-2-20 0-38 3-54 11-16 7-30 17-41 30-11 12-20 27-28 45-6 17-10 36-10 56 0 18 3 35 7 50 3 16 10 31 17 44 8 14 16 26 26 36 10 11 23 20 35 28 13 7 27 13 42 17 15 4 30 6 46 6 14 0 26-1 36-3 11-3 21-7 30-10 9-4 16-9 24-15 6-5 12-12 19-18l-24-29c-4-5-9-8-14-8-5-2-11 0-16 3-5 4-10 7-15 9-5 3-9 5-14 6-5 2-10 3-15 4-5 1-11 1-17 1-14 0-27-2-38-8-11-7-21-14-30-25-9-12-15-24-19-39-5-15-7-31-7-50 0-10 1-23 5-34z" horiz-adv-x="1000" />
-<glyph glyph-name="git" unicode="&#xe805;" d="m934 851h-868c-37 0-66-30-66-67v-869c0-36 29-65 66-65h869c36 0 66 30 66 66v868c0 37-30 67-67 67z m-738-557c4-11 9-20 15-29 7-7 14-14 23-17 9-4 19-7 29-7 8 0 16 2 23 3 8 1 14 4 20 6l7 53h-28c-4 0-7 1-10 3-2 3-4 5-2 9l5 40h106l-16-134c-9-6-17-11-25-15-9-3-18-7-28-10-10-2-20-5-30-6-11-2-22-2-35-2-20 0-37 3-54 11-16 7-30 17-41 30-11 12-20 27-27 45-7 17-10 36-10 56 0 18 2 35 6 50 4 16 10 31 17 44 8 14 17 26 27 36 10 11 22 20 35 28 12 7 26 13 41 17 15 4 30 6 46 6 14 0 26-1 38-3 11-3 21-7 30-10 8-4 16-9 23-15 8-5 13-12 19-18l-25-26c-4-5-9-9-14-9-5-1-11 0-16 4-5 4-10 6-15 9-5 2-9 5-14 6-5 1-10 2-15 4-5 1-11 1-17 1-14 0-26-3-38-9-11-6-21-14-30-25-8-11-15-24-18-39-5-15-8-31-8-50 1-13 3-26 6-37z m340-104h-71l39 319h71l-39-319z m348 263h-81l-33-263h-70l33 263h-83l8 56h233l-7-56z" horiz-adv-x="1000" />
-<glyph glyph-name="plus" unicode="&#xe806;" d="m958 408v-120c0-17-12-34-33-34h-304c-17 0-33-12-33-33v-304c0-17-13-34-34-34h-121c-16 0-33 13-33 34v308c0 17-12 33-33 33h-296c-17 0-33 13-33 34v121c0 16 12 33 33 33h304c17 0 33 12 33 33v296c0 17 13 33 34 33h121c16 0 33-12 33-33v-304c0-17 12-33 33-33h304c13 4 25-13 25-30z" horiz-adv-x="1000" />
-<glyph glyph-name="minus" unicode="&#xe807;" d="m942 258h-884c-8 0-16 9-16 17v154c0 4 8 13 16 13h888c8 0 17-9 17-17v-154c-5-4-13-13-21-13z" horiz-adv-x="1000" />
-<glyph glyph-name="remove" unicode="&#xe808;" d="m942 688l-109 108c-12 12-33 12-45 0l-267-267c-13-12-33-12-46 0l-267 267c-12 12-33 12-45 0l-113-108c-12-13-12-34 0-46l267-267c12-12 12-33 0-46l-267-266c-12-13-12-34 0-46l108-109c17-16 38-16 50-4l267 267c13 12 33 12 46 0l267-267c12-12 33-12 45 0l109 109c12 12 12 33 0 45l-267 267c-12 13-12 33 0 46l267 267c12 12 12 33 0 50z" horiz-adv-x="1000" />
-<glyph glyph-name="bookmark" unicode="&#xe809;" d="m767-96l-234 267c-8 12-25 12-33 0l-233-267c-17-17-42-4-42 25v842c0 17 13 33 25 33h533c13 0 25-16 25-33v-838c0-29-25-46-41-29z" horiz-adv-x="1000" />
-<glyph glyph-name="branch" unicode="&#xe80a;" d="m829 579c0 67-54 121-121 121s-125-54-125-121c0-41 21-79 59-104-17-129-125-167-192-179v287c38 21 63 59 63 105 0 66-55 120-125 120s-121-54-121-120c0-46 25-84 62-105v-458c-37-25-62-62-62-108 0-67 54-121 121-121s120 54 120 121c0 46-25 83-62 104v50c58 8 154 29 225 100 50 50 79 117 87 196 46 25 71 66 71 112z m-441 150c20 0 41-16 41-41s-16-42-41-42c-21 0-42 17-42 42s21 41 42 41z m0-750c-21 0-42 17-42 42 0 21 17 42 42 42 20 0 41-17 41-42 0-25-16-42-41-42z m320 642c21 0 42-17 42-42s-17-41-42-41c-20 0-41 16-41 41s16 42 41 42z" horiz-adv-x="1000" />
-<glyph glyph-name="tag" unicode="&#xe80b;" d="m433 800l-316 8c-38 0-71-33-71-70l8-317c0-17 9-33 21-46l442-442c25-25 71-25 96 0l308 309c25 25 25 71 0 96l-442 441c-8 13-25 17-46 21z m-83-225c0-37-29-67-67-67-37 0-66 30-66 67-4 38 25 67 62 67s71-29 71-67z" horiz-adv-x="1000" />
-<glyph glyph-name="lock" unicode="&#xe80c;" d="m817 429h-50v109c0 8 0 12 0 20 0 5 0 9 0 13 0 4 0 4 0 8 0 9-4 17-4 25 0 4 0 9-5 9-4 8-4 16-8 25 0 0 0 0 0 4-4 8-8 21-12 29 0 4-5 4-5 4-4 8-8 13-12 21 0 4-4 4-4 8-4 4-9 13-13 17 0 4-4 4-4 8-8 9-12 13-21 21 0 0-4 0-4 4-8 4-12 13-21 17-4 0-4 4-8 4-8 4-13 8-21 13-4 0-4 4-8 4-9 4-17 8-29 12 0 0 0 0 0 0-9 4-21 4-30 9-4 0-4 0-8 0-4 0-8 0-8 0 0 0-4 0-4 0 0 0-5 0-5 0 0 0 0 0 0 0 0 0 0 0 0 0-4 0-8 0-8 0-4 0-4 0-8 0-4 0-4 0-9 0 0 0 0 0 0 0-4 0-8 0-8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0-4 0-4 0 0 0-4 0-4 0-4 0-9 0-9 0-4 0-8 0-8 0-8 0-21-5-29-9 0 0 0 0 0 0-38-12-50-16-58-21-5 0-5-4-9-4-4 0-12-4-16-8-5-4-9-4-9-4-8-4-16-13-25-17 0 0-4 0-4-4-4-4-12-13-21-21 0 0-4-4-4-8-4 0-12-9-17-13 0-4-4-4-4-8-4-8-8-13-12-21 0 0-4-4-4-4-5-13-9-21-13-29 0-4 0-4-4-9-4-8-4-12-8-20 0-5 0-9-5-9 0-8-4-16-4-25 0-4 0-4 0-8 0-4 0-8 0-13 0-8 0-12 0-20v-109h-46c-16 0-29-12-29-29v-475c0-17 13-29 29-29h638c17 0 29 12 29 29v475c-4 17-17 29-33 29z m-459 109c0 66 50 125 113 137 0 0 4 0 4 0 8 0 17 0 21 4 0 0 4 0 4 0 0 0 0 0 0 0 8 0 17 0 21-4 0 0 4 0 4 0 63-12 113-71 113-137v-109h-280v109z" horiz-adv-x="1000" />
-<glyph glyph-name="unlock" unicode="&#xe80d;" d="m817 429h-459v109c0 66 50 125 113 137 0 0 4 0 4 0 8 0 17 0 21 4 0 0 4 0 4 0 0 0 0 0 4 0 9 0 17 0 25-4 0 0 0 0 0 0 9 0 17-4 25-8 0 0 4 0 4-4 9-5 13-9 21-13 0 0 0 0 0 0 9-4 13-8 17-17 0 0 4-4 4-4 4-4 8-8 13-16 0 0 0-5 4-5 4-8 8-12 12-20 0 0 0-5 4-5 5-8 5-12 5-20 0 0 0-5 0-5 0 0 0 0 0-4 4-12 16-25 29-25h66c17 0 30 17 30 34 0 0 0 0 0 0 0 4 0 4 0 4 0 8-5 16-5 25 0 4 0 8-4 8-4 8-4 17-8 21 4 17 4 17 4 21-4 8-8 16-12 29 0 4-5 4-5 4-4 8-8 13-12 21 0 4-4 4-4 8-4 4-9 13-13 17 0 4-4 4-4 8-8 9-12 13-21 21 0 0-4 0-4 4-8 4-12 13-21 17-12-4-16-4-16-4-9 4-13 8-21 12-4 0-4 4-9 4-8 5-16 9-29 13 0 0 0 0 0 0-8 4-21 4-29 8-4 0-4 0-8 0-9 0-17 0-25 4-4 0-9 0-9 0-8 0-16 0-29 0 0 0-4 0-4 0-8 0-21-4-29-4-8 0-13-4-21-4 0 0-4 0-4 0-113-42-188-142-188-262v-109h-50c-16 0-29-12-29-29v-475c0-17 13-29 29-29h634c16 0 29 12 29 29v475c0 17-13 29-29 29z" horiz-adv-x="1000" />
-<glyph glyph-name="delete" unicode="&#xe80e;" d="m500 804c-254 0-454-204-454-454 0-250 204-454 454-454s454 204 454 454c0 250-204 454-454 454z m267-491c0-17-17-34-34-34h-466c-21 0-34 13-34 34v75c0 16 17 33 34 33h466c21 0 34-13 34-33v-75z" horiz-adv-x="1000" />
-<glyph glyph-name="ok" unicode="&#xe80f;" d="m500 804c-250 0-454-204-454-454 0-250 204-454 454-454s454 204 454 454c0 250-204 454-454 454z m283-346l-358-358c-12-12-33-12-46 0l-162 163c-13 12-13 33 0 45l50 50c12 13 33 13 46 0l66-66c13-13 34-13 46 0l263 262c12 13 33 13 45 0l50-50c13-16 13-37 0-46z" horiz-adv-x="1000" />
-<glyph glyph-name="comment" unicode="&#xe810;" d="m42-13v601c0 87 71 154 154 154h600c87 0 154-71 154-154v-342c0-88-71-154-154-154h-583c-9 0-13-4-17-9l-113-112c-12-17-41-4-41 16z m158 684c-46 0-87-38-87-88v-487l54 54c4 4 12 8 16 8h617c46 0 88 38 88 88v342c0 45-38 87-88 87h-600z" horiz-adv-x="1000" />
-<glyph glyph-name="feed" unicode="&#xe811;" d="m888 804h-780c-37 0-66-29-66-66v-780c0-37 29-66 66-66h780c37 0 66 29 66 66v780c0 37-29 66-66 66z m-638-787c-46 0-83 37-83 83 0 46 37 88 87 88 46 0 88-38 88-88-4-46-46-83-92-83z m292-13c-38 0-71 34-71 71 0 133-108 238-238 238-37 0-75 29-75 66 0 38 25 71 63 71l12 0c209 0 380-171 380-379 0-33-30-67-71-67z m237 0c-37 0-71 34-71 71 0 263-212 475-475 475-37 0-75 29-75 67 0 37 25 71 63 71l12 0c338 0 613-275 613-613 4-37-29-71-67-71z" horiz-adv-x="1000" />
-<glyph glyph-name="right" unicode="&#xe812;" d="m308-96l-75 75c-12 13-12 29 0 42l309 308c12 13 12 29 0 42l-317 312c-12 13-12 30 0 42l75 75c13 13 29 13 42 0l433-433c13-13 13-29 0-42l-425-421c-8-12-29-12-42 0z" horiz-adv-x="1000" />
-<glyph glyph-name="left" unicode="&#xe813;" d="m683 800l75-75c13-12 13-29 0-42l-308-308c-12-12-12-29 0-42l317-316c12-13 12-30 0-42l-75-75c-13-13-29-13-42 0l-433 433c-13 13-13 30 0 42l425 425c12 13 29 13 41 0z" horiz-adv-x="1000" />
-<glyph glyph-name="arrow_down" unicode="&#xe814;" d="m950 542l-412-521c-17-21-50-21-67 0l-417 521c-21 25-4 71 34 71h829c37 0 58-46 33-71z" horiz-adv-x="1000" />
-<glyph glyph-name="group" unicode="&#xe815;" d="m958 221v-17c0-4-4-8-8-8h-167-4c-16 21-41 37-79 46-37 4-58 16-71 25 9 8 17 12 34 16 45 9 62 21 66 38s9 25 0 37c-8 13-33 46-33 84 0 41 0 104 75 108h8 13c75-4 79-71 75-108 0-42-25-71-34-84-8-16-8-25 0-37s21-29 67-38c54-12 58-58 58-62 0 0 0 0 0 0z m-725-17c17 17 38 34 71 38 42 8 63 16 75 25-8 8-21 16-37 21-46 8-63 20-67 37-8 13-8 25 0 38 8 12 33 45 33 83 0 42 0 104-75 108h-12-8c-75-4-80-71-80-108 0-42 25-71 34-83 8-17 8-25 0-38-9-12-21-29-67-37-50-9-54-50-54-59 0 0 0 0 0 0v-16c0-5 4-9 8-9h167 12z m463 13c-75 12-96 37-108 58-13 21-13 42 0 63 12 25 50 70 54 133 4 62 0 167-121 175h-21-17c-116-4-120-113-120-175 4-63 41-113 54-133 12-25 12-42 0-63-13-21-38-46-109-58-75-13-87-84-87-92 0 0 0 0 0 0v-25c0-8 8-17 17-17h262 267c8 0 16 9 16 17v25c0 0 0 0 0 0 0 8-8 79-87 92z" horiz-adv-x="1000" />
-<glyph glyph-name="folder" unicode="&#xe816;" d="m742 17h-659c-12 0-25 8-33 16-8 13-8 25 0 38l179 342c4 12 17 20 34 20h658c12 0 25-8 33-16 9-13 9-25 0-38l-179-341c-8-13-21-21-33-21z m-596 75h575l142 266h-580l-137-266z m-29-38h-75v550c0 21 16 38 37 38h246c8 0 21-4 25-13l54-54h325c21 0 38-17 38-37v-105h-75v67h-300c-9 0-17 4-25 8l-59 59h-191v-513z" horiz-adv-x="1000" />
-<glyph glyph-name="fork" unicode="&#xe817;" d="m838 688c0 66-55 120-121 120-67 0-121-54-121-120 0-42 21-80 54-100-12-100-83-146-150-167-71 21-137 67-150 167 33 20 54 58 54 100 0 66-54 120-121 120s-120-54-120-120c0-46 29-88 66-109 13-129 88-225 213-271v-191c-38-21-63-59-63-100 0-67 54-121 121-121s121 54 121 121c0 46-25 83-58 104v192c120 45 200 137 212 270 33 17 63 59 63 105z m-555 37c21 0 42-17 42-42s-17-41-42-41-41 16-41 41 21 42 41 42z m217-750c-21 0-42 17-42 42 0 21 17 41 42 41s42-16 42-41c0-25-21-42-42-42z m217 750c21 0 41-17 41-42s-16-41-41-41-42 16-42 41 21 42 42 42z" horiz-adv-x="1000" />
-<glyph glyph-name="more" unicode="&#xe818;" d="m592 408v-120c0-17-13-34-34-34h-120c-17 0-34 13-34 34v120c0 17 13 34 34 34h120c21 0 34-17 34-34z m-34 400h-120c-17 0-34-12-34-33v-121c0-16 13-33 34-33h120c17 0 34 12 34 33v121c0 21-13 33-34 33z m0-733h-120c-17 0-34-12-34-33v-121c0-17 13-34 34-34h120c17 0 34 13 34 34v121c0 16-13 33-34 33z" horiz-adv-x="1000" />
-<glyph glyph-name="comment-add" unicode="&#xe819;" d="m48-12v593c0 86 69 155 154 155h596c85 0 154-69 154-155v-338c0-86-69-155-154-155h-584c-7 0-12-2-16-7l-110-110c-14-14-40-4-40 17z m154 679c-47 0-85-38-85-86v-486l52 53c5 4 10 7 17 7h612c47 0 85 38 85 86v340c0 48-38 86-85 86h-596z m479-284l0 48c0 5-5 10-10 10l-114 0c-5 0-9 4-9 9v114c0 5-5 10-10 10h-47c-5 0-10-5-10-10v-114c0-5-5-9-10-9h-114c-5 0-9-5-9-10v-48c0-4 4-9 9-9h114c5 0 10-5 10-10l0-114c0-5 5-9 10-9l47 0c5 0 10 4 10 9v114c0 5 4 10 9 10h114c5-3 10 2 10 9z" horiz-adv-x="1000" />
+<glyph glyph-name="delete" unicode="&#xe800;" d="M515 758c-211 0-384-173-384-385 0-211 173-385 384-385s385 174 385 385c0 212-173 385-385 385z m227-416c0-15-11-27-30-27h-397c-15 0-30 12-30 27v62c0 15 11 27 30 27h397c15 0 30-12 30-27v-62z" horiz-adv-x="1000" />
+
+<glyph glyph-name="ok" unicode="&#xe801;" d="M515 735c-211 0-384-173-384-385 0-211 173-385 384-385s385 174 385 385c0 212-173 385-385 385z m239-296l-304-304c-11-12-27-12-38 0l-139 138c-11 12-11 27 0 39l42 42c12 11 27 11 39 0l58-58c11-11 27-11 38 0l219 219c12 12 27 12 39 0l42-42c15-8 15-23 4-34z" horiz-adv-x="1000" />
+
+<glyph glyph-name="comment" unicode="&#xe802;" d="M131 65v504c0 73 58 131 131 131h507c73 0 131-58 131-131v-288c0-73-58-131-131-131h-496c-4 0-11-4-15-8l-93-92c-11-15-34-4-34 15z m131 574c-39 0-73-31-73-74v-411l46 46c4 4 7 8 15 8h519c39 0 73 31 73 73v288c0 39-30 73-73 73h-507z" horiz-adv-x="1000" />
+
+<glyph glyph-name="bookmark" unicode="&#xe803;" d="M780-140l-260 290c-10 10-25 10-35 0l-260-295c-20-20-45-5-45 30v930c-5 20 10 35 25 35h590c15 0 30-15 30-35v-925c0-35-30-50-45-30z" horiz-adv-x="1000" />
+
+<glyph glyph-name="branch" unicode="&#xe804;" d="M875 600c0 76-58 134-134 134s-134-58-134-134c0-49 27-89 63-112-18-142-139-183-210-196v313c45 22 71 62 71 111 0 76-58 134-134 134s-134-58-134-134c0-49 27-94 67-116v-500c-40-22-67-67-67-116 0-76 58-134 134-134s134 58 134 134c0 49-26 94-67 116v58c63 9 166 31 246 112 58 58 89 129 98 214 40 22 67 67 67 116z m-478 161c27 0 45-18 45-45s-18-45-45-45-44 18-44 45 18 45 44 45z m0-822c-26 0-44 18-44 45s18 45 44 45 45-18 45-45-22-45-45-45z m344 706c27 0 45-18 45-45s-18-45-45-45-45 18-45 45 23 45 45 45z" horiz-adv-x="1000" />
+
+<glyph glyph-name="tag" unicode="&#xe805;" d="M460 788l-366 8c-18 0-31-13-31-31l13-366c0-9 4-13 9-22l464-465c14-13 31-13 45 0l352 353c14 14 14 31 0 45l-468 469c-5 4-14 9-18 9z m-103-224c0-35-31-67-67-67-35 0-67 32-67 67 0 36 32 67 67 67s67-26 67-67z" horiz-adv-x="1000" />
+
+<glyph glyph-name="lock" unicode="&#xe806;" d="M813 426h-54v107c0 9 0 13 0 18 0 4 0 9 0 13 0 5 0 5 0 9 0 9 0 14-4 23 0 4 0 4-5 9 0 8-4 13-9 22 0 0 0 4-4 4-5 9-9 18-14 27 0 0-4 5-4 5 4 8 0 17-5 22 0 4-4 4-4 9-5 4-9 13-14 18 0 0-4 4-4 4-9 9-13 14-22 22 0 0-5 0-5 5-4 4-13 9-22 13-5 0-5 5-9 5-4 4-13 9-18 9-4 0-4 4-9 4-9 5-18 9-27 9 0 0 0 0 0 0-9 5-17 5-31 9-4 0-4 0-9 0-4 0-4 0-9 0 0 0-4 0-4 0 0 0-5 0-5 0 0 0 0 0 0 0 0 0 0 0 0 0-4 0-9 0-9 0 0 0-4 0-4 0-4 0-4 0-9 0 0 0 0 0 0 0-4 0-9 0-9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0-4 0-4 0 0 0-5 0-5 0-4 0-4 0-9 0-4 0-4 0-9 0-9 0-22-4-31-9 0 0 0 0 0 0-22 0-36-4-45-9-4 0-4-4-8-4-5-5-9-5-18-9 0-5-5-5-5-5-9-4-18-9-22-18 0 0-5 0-5-4-9-4-13-9-22-18 0 0-4-4-4-4-5-5-9-14-14-18 0-5-4-5-4-9-9-5-14-14-14-18-4 0-4-4-4-4-5-9-9-18-13-27 0 0 0-5-5-5 0-13-4-18-4-26 0-5 0-5-5-9 0-9-4-14-4-23 0-4 0-4 0-9 0-4 0-9 0-13 0-5 0-13 0-18v-107h-49c-18 0-27-13-27-27v-464c0-18 13-27 27-27h620c18 0 27 13 27 27v464c4 18-9 27-22 27z m-451 107c0 67 49 121 111 134 0 0 0 0 5 0 9 0 13 0 22 0 0 0 5 0 5 0 0 0 0 0 0 0 8 0 13 0 22 0 0 0 0 0 4 0 63-13 112-67 112-134v-107h-281v107z" horiz-adv-x="1000" />
+
+<glyph glyph-name="unlock" unicode="&#xe807;" d="M781 415h-385v93c0 57 43 104 96 115 0 0 0 0 4 0 8 0 12 0 19 0 0 0 4 0 4 0 0 0 0 0 4 0 8 0 16 0 23-4 0 0 0 0 0 0 8 0 12-4 19-7 0 0 4 0 4-4 4-4 12-4 16-8 0 0 0 0 0 0 4-4 11-8 15-11 0 0 4-4 4-4 4-4 8-8 11-12 0 0 0 0 4-4 4-4 8-11 12-19 0 0 0-4 0-4 4-4 4-11 4-15 0 0 0-4 0-4 0 0 0 0 0-4 4-11 11-19 23-19h57c16 0 27 11 24 27 0 0 0 0 0 0 0 0 0 4 0 4 0 7-4 11-4 19 0 4 0 4-4 8 0 15 0 19-4 27 0 0 0 3-4 3-4 8-8 16-11 23 0 0-4 4-4 4-4 8-8 12-12 16 0 4-4 4-4 7-3 4-7 12-11 16 0 0-4 4-4 4-8 7-12 11-19 19 0 0-4 0-4 4-4 4-12 7-19 11-4 0-4 4-8 4-4 4-12 8-15 8-4 0-4 4-8 4-8 3-15 7-23 7 0 0 0 0 0 0-8 4-16 4-27 8-4 0-4 0-8 0-7 0-11 0-19 4-4 0-8 0-8 0-7 0-15 0-23 0 0 0-4 0-4 0-7 0-15-4-27-4-3 0-11-4-15-4 0 0-4 0-4 0-92-27-157-115-157-215v-93h-43c-15 0-23-11-23-23v-400c0-15 12-23 23-23h535c15 0 23 12 23 23v400c4 12-8 23-23 23z" horiz-adv-x="1000" />
+
+<glyph glyph-name="feed" unicode="&#xe808;" d="M842 739h-653c-35 0-58-27-58-58v-658c0-31 27-58 58-58h657c31 0 58 27 58 58v658c-4 31-31 58-62 58z m-534-666c-39 0-73 31-73 73s30 73 73 73c38 0 73-30 73-73s-35-73-73-73z m246-11c-35 0-58 27-58 57 0 112-88 200-200 200-31 0-65 27-65 58 0 35 23 62 54 62l11 0c177 0 319-143 319-320-3-30-30-57-61-57z m196 0c-35 0-58 27-58 57 0 220-180 400-400 400-30 0-65 27-65 62 0 34 23 61 54 61l11 0c285 0 520-230 520-519 0-34-27-61-62-61z" horiz-adv-x="1000" />
+
+<glyph glyph-name="left" unicode="&#xe809;" d="M692 773l70-69c11-12 11-27 0-39l-289-288c-11-12-11-27 0-38l296-297c12-11 12-27 0-38l-69-69c-11-12-27-12-38 0l-404 404c-12 11-12 26 0 38l396 396c11 12 27 12 38 0z" horiz-adv-x="1000" />
+
+<glyph glyph-name="right" unicode="&#xe80a;" d="M339-65l-74 69c-11 11-11 27 0 38l289 289c11 11 11 27 0 38l-296 296c-12 12-12 27 0 39l69 69c12 12 27 12 38 0l404-404c12-11 12-27 0-38l-392-396c-12-12-31-12-38 0z" horiz-adv-x="1000" />
+
+<glyph glyph-name="arrow_down" unicode="&#xe80b;" d="M704 454l-173-219c-8-8-23-8-27 0l-173 219c-8 11 0 31 15 31h346c12 0 20-20 12-31z" horiz-adv-x="1000" />
+
+<glyph glyph-name="group" unicode="&#xe80f;" d="M962 219v-15c0-4-4-12-12-12h-161-4c-16 20-39 39-77 43-35 7-54 15-69 23 7 7 19 11 30 15 46 8 58 23 66 35 7 11 7 23 0 38-8 16-31 43-31 81 0 38 0 104 73 104h8 7c73-4 77-66 73-104 0-38-23-69-30-81-8-15-8-27 0-38 7-12 23-27 65-35 54-4 62-46 62-54 0 0 0 0 0 0z m-708-15c15 15 38 31 69 35 39 7 62 15 73 26-7 8-19 16-34 20-47 7-58 23-66 34-7 12-7 23 0 39 8 15 31 42 31 81 0 38 0 103-73 103h-8-11c-73-3-77-65-73-103 0-39 23-70 30-81 8-16 8-27 0-39-7-11-23-27-65-34-46-8-54-50-54-54 0 0 0 0 0 0v-16c0-3 4-11 12-11h161 8z m454 11c-73 12-96 35-108 54-11 20-11 39 0 62 12 23 50 69 54 131 4 61 0 165-119 169h-16-15c-119-4-123-104-119-166 4-61 38-107 54-130 11-23 11-43 0-62-12-19-35-42-108-54-73-11-85-80-85-88 0 0 0 0 0 0v-23c0-8 8-16 16-16h257 258c8 0 15 8 15 16v23c0 0 0 0 0 0-3 4-11 73-84 84z" horiz-adv-x="1000" />
+
+<glyph glyph-name="folder" unicode="&#xe810;" d="M735 73h-604c-12 0-23 8-31 16-8 11-8 23 0 34l165 312c8 11 20 19 31 19h604c12 0 23-8 31-15 8-12 8-24 0-35l-166-312c-7-11-19-19-30-19z m-546 69h523l127 243h-520l-130-243z m-24-34h-69v504c0 19 16 34 35 34h223c8 0 19-4 23-11l50-50h304c19 0 34-16 34-35v-96h-69v61h-277c-7 0-19 4-23 12l-54 50h-177v-469z" horiz-adv-x="1000" />
+
+<glyph glyph-name="fork" unicode="&#xe811;" d="M792 654c0 58-46 100-100 100-57 0-100-46-100-100 0-35 20-65 47-85-12-84-70-123-127-142-58 15-116 54-127 142 27 20 46 50 46 85 0 58-46 100-100 100s-108-42-108-100c0-39 23-73 54-89 12-107 77-188 181-226v-162c-31-19-50-50-50-88 0-58 46-101 100-101s100 47 100 101c0 38-19 69-50 88v162c104 38 169 119 181 226 30 20 53 50 53 89z m-465 35c19 0 35-16 35-35s-16-31-35-31-35 12-35 31 16 35 35 35z m181-635c-19 0-35 15-35 35s16 34 35 34c19 0 34-15 34-34s-15-35-34-35z m184 635c20 0 35-16 35-35s-15-31-35-31-34 16-34 35 15 31 34 31z" horiz-adv-x="1000" />
+
+<glyph glyph-name="more" unicode="&#xe812;" d="M546 435h-100c-15 0-27-12-27-27v-100c0-16 12-27 27-27h100c16 0 27 11 27 27v100c0 15-11 27-27 27z m0 307h-100c-15 0-27-11-27-27v-100c0-15 12-26 27-26h100c16 0 27 11 27 26v100c0 16-11 27-27 27z m0-615h-100c-15 0-27-12-27-27v-100c0-15 12-27 27-27h100c16 0 27 12 27 27v100c0 15-11 27-27 27z" horiz-adv-x="1000" />
+
+<glyph glyph-name="plus" unicode="&#xe813;" d="M873 404h-254c-15 0-27 11-27 27v254c0 15-11 27-27 27h-100c-15 0-26-12-26-27v-254c0-16-12-27-27-27h-254c-16 0-27-12-27-27v-100c0-15 11-27 27-27h254c15 0 27-11 27-27v-254c0-15 11-27 26-27h100c16 0 27 12 27 27v254c0 16 12 27 27 27h254c16 0 27 12 27 27v100c0 15-11 27-27 27z" horiz-adv-x="1000" />
+
+<glyph glyph-name="minus" unicode="&#xe814;" d="M980 290h-960c-10 0-20 10-20 20v160c0 10 10 20 20 20h965c10 0 20-10 20-20v-165c-5-5-15-15-25-15z" horiz-adv-x="1000" />
+
+<glyph glyph-name="remove" unicode="&#xe815;" d="M975 710l-115 115c-15 15-35 15-50 0l-285-285c-15-15-35-15-50 0l-285 285c-15 15-35 15-50 0l-115-115c-15-15-15-35 0-50l285-285c15-15 15-35 0-50l-285-285c-15-15-15-35 0-50l115-115c15-15 35-15 50 0l285 285c15 15 35 15 50 0l285-285c15-15 35-15 50 0l115 115c15 15 15 35 0 50l-285 285c-15 15-15 35 0 50l285 285c15 10 15 35 0 50z" horiz-adv-x="1000" />
+
+<glyph glyph-name="git" unicode="&#xe82a;" d="M929 844h-858c-36 0-65-30-65-65v-857c0-36 30-65 65-65h857c36 0 65 30 65 65v857c1 35-29 65-64 65z m-729-549c4-11 9-20 14-27 6-8 14-14 22-18 9-4 19-6 29-6 9 0 16 1 24 2 7 2 14 4 20 7l6 51h-27c-4 0-8 1-10 4-2 1-3 5-3 7l5 39h105l-16-131c-8-7-16-12-25-15-9-4-18-8-28-10-10-3-18-5-30-7-10-1-21-2-33-2-20 0-38 4-54 11-16 8-30 18-41 30-12 13-20 28-27 45-6 18-10 36-10 56 0 18 3 34 7 50 3 17 10 30 17 44 8 14 16 25 26 36 10 12 22 20 34 28 13 7 26 14 41 17 15 4 30 7 47 7 13 0 25-2 36-4 11-3 21-6 29-10 8-4 16-9 22-14 6-5 13-11 18-16l-20-31c-4-5-9-8-14-9-5-1-10 0-16 4-5 3-10 6-14 8-5 3-9 5-14 7-5 1-10 2-15 3-5 2-11 2-17 2-14 0-27-3-38-9-11-6-21-14-29-25-8-10-15-24-18-38-5-15-7-31-7-48-1-14 2-27 4-38z m336-102h-71l39 315h71l-39-315z m343 258h-80l-33-258h-70l32 258h-80l7 57h231l-7-57z" horiz-adv-x="1000" />
+
+<glyph glyph-name="hg" unicode="&#xe82d;" d="M927 841h-853c-36 0-65-29-65-65v-853c0-36 29-65 65-65h853c36 0 65 29 65 65v853c0 36-29 65-65 65z m-483-648h-70l16 133h-113l-17-133h-70l39 313h70l-16-132h113l16 132h71l-39-313z m177 101c3-11 8-20 14-27 7-8 14-14 23-18 8-4 18-6 28-6 9 0 16 1 23 3 7 1 14 3 20 6l6 51h-27c-4 0-7 1-9 3-3 3-3 6-3 9l5 39h104l-16-131c-8-6-16-11-25-15-9-5-18-8-27-11-9-2-19-4-30-6-10-1-21-2-33-2-19 0-37 4-53 11-16 7-30 17-41 29-11 13-20 28-26 45-7 17-10 35-10 55 0 17 2 34 6 50 4 15 10 30 17 43 7 14 16 26 26 36 10 11 22 20 34 28 13 7 27 13 41 17 14 4 30 7 46 7 13 0 25-2 36-4 11-3 20-6 29-10 8-4 16-9 23-14 7-5 13-11 18-17l-23-28c-4-5-8-8-13-9-5-1-11 0-16 3-5 4-10 7-14 9-5 3-9 5-14 6-4 2-9 3-14 4-5 1-11 1-17 1-14 0-27-3-38-8-11-6-21-14-29-25-8-10-15-23-19-38-5-15-7-31-7-49 0-13 2-26 5-37z" horiz-adv-x="1000" />
+
+<glyph glyph-name="svn" unicode="&#xe82e;" d="M933 841h-852c-36 0-65-29-65-65v-853c0-36 29-65 65-65h852c36 0 66 29 66 65v853c0 36-30 65-66 65z m-765-438c3-4 7-7 13-10 5-3 11-6 18-8 7-3 14-5 21-8 7-3 14-6 21-10 7-4 13-9 18-14 5-6 10-13 13-20 3-8 5-18 5-29 0-16-3-30-8-44-6-14-14-26-24-37-10-10-22-18-37-24-15-7-31-10-49-10-9 0-18 1-27 3s-18 5-27 9c-8 4-16 8-23 13-7 5-13 10-18 17l25 32c2 3 4 5 7 6 3 2 6 3 9 3 4 0 8-2 12-4 3-3 8-6 12-10 5-3 10-6 16-9 6-3 14-4 23-4 13 0 23 3 30 10 7 7 10 18 10 32 0 6-1 12-4 16-4 4-8 7-13 10-5 3-11 6-18 8-7 2-14 5-21 7-7 3-14 6-21 9-6 4-12 8-18 14-5 6-9 13-12 21-3 8-5 18-5 30 0 14 3 28 8 40 5 13 12 25 22 35 10 9 22 17 36 23 14 6 29 9 47 9 9 0 17-1 26-3s16-4 23-8c7-3 14-7 20-11 6-5 11-10 15-15l-21-29c-2-3-5-6-7-7-3-2-6-3-9-3-3 0-7 1-10 3-3 3-7 5-11 8-4 2-9 4-14 7-5 2-12 3-19 3-6 0-12-1-17-3-5-2-9-4-12-8-4-3-6-7-8-11-1-5-2-10-2-15 0-5 2-10 5-14z m312-210h-64l-77 313h57c6 0 10-1 14-4 4-3 6-6 7-11l32-173c2-7 4-14 6-23 1-8 3-17 4-26 3 9 6 18 9 26 4 9 7 16 11 23l73 173c1 2 2 4 4 6 2 2 4 3 6 5 2 1 4 2 7 3 3 1 5 1 8 1h57l-154-313z m423 0h-37c-5 0-10 1-13 2-4 2-7 5-10 9l-109 194c-1-4-1-8-1-12-1-4-1-7-1-10l-22-183h-62l39 313h37c3 0 6 0 8 0 2 0 4-1 5-1 2-1 3-2 4-4s3-3 5-5l110-194c0 5 0 10 1 14 0 5 1 9 1 13l21 177h62l-38-313z" horiz-adv-x="1000" />
+
+<glyph glyph-name="comment-add" unicode="&#xe82f;" d="M952 258v317c0 7 0 13 0 20-1 12-4 24-8 36-7 22-20 43-37 59-16 17-36 30-58 37-12 4-25 7-37 8-7 1-13 1-19 1h-576c-13 0-26 0-38-2-13-2-25-5-36-10-22-9-41-23-57-40-15-18-27-39-33-62-3-12-5-25-5-38-1-13 0-26 0-39v-557c0-9 5-17 13-21 6-3 15-3 21 0 3 1 5 3 7 5 2 2 4 5 7 7 4 5 9 9 14 14l28 28c9 10 19 19 28 29 9 9 19 18 28 27 4 5 8 9 14 10 2 1 5 1 8 1h567c13 0 25 0 38 2 24 4 47 13 66 27 19 13 35 31 46 51 12 22 19 46 19 71 1 6 0 13 0 19z m-69 307v-317c0-7 0-13 0-19-1-6-3-13-5-18-4-10-9-20-16-28-15-17-37-27-59-28-7 0-13 0-19 0h-576c-7 0-13 0-20 0-3 0-6 0-9-1-3-1-5-2-7-4-2-2-4-4-6-6-3-2-5-4-7-7-5-4-10-9-14-14-10-9-19-18-28-28v485c0 12 2 24 7 35 4 10 10 19 18 27 16 16 38 25 60 25h590c6 0 12 0 18-1 22-3 42-15 56-33 7-9 12-20 15-31 1-5 2-12 2-18 1-6 0-13 0-19z m-214-117h-131c-4 0-11 8-11 12v126c0 8-8 16-12 16h-50c-7 0-15-8-15-12v-130c0-4-8-12-12-12h-126c-8 0-16-8-16-11v-50c0-8 8-16 12-16h127c7 0 15-7 15-11v-127c0-8 8-15 11-15h50c8 0 16 7 16 11v127c0 8 7 15 11 15h127c8 0 15 8 15 12v50c0 7-7 15-11 15z" horiz-adv-x="1000" />
+
+<glyph glyph-name="comment-toggle" unicode="&#xe830;" d="M798 736h-596c-85 0-154-69-154-155v-593c0-19 22-29 36-20 2 1 5 3 7 5l109 109c2 2 5 4 8 5 2 1 4 1 6 1h584c85 0 154 69 154 155v338c0 86-69 155-154 155z m-680-639v484c0 47 38 85 86 85h476c-86-84-504-511-509-515l-53-54z" horiz-adv-x="1000" />
+
+<glyph glyph-name="rhodecode" unicode="&#xe831;" d="M175 633c-2-4-3-8-4-12-3-10-6-20-9-30-3-13-7-25-11-38-3-11-6-23-10-35-2-7-4-15-6-22-1-1-1-2-1-4 0 0 0 0 0 0 0-1 1-2 1-2 2-7 5-14 7-21 4-11 8-22 12-33 4-12 9-25 13-37 4-11 8-23 12-34 3-7 5-14 7-21 1-1 1-2 2-3 0-1 1-1 1-2 4-6 8-12 11-17 7-10 13-19 19-29 7-11 14-22 22-33 6-10 13-21 20-31 5-7 9-15 14-22 1-2 3-4 4-5 0-1 1-1 1-2 3-3 6-5 8-8 7-6 13-12 19-19 9-8 17-16 25-24 10-10 19-19 29-28 9-9 18-18 27-27 8-8 16-15 23-23 5-5 11-10 16-15 1-1 3-3 5-5 7-5 14-10 21-15 11-8 21-15 31-23 4-2 7-5 11-7 0-1 1-2 2-2 0 0 0-1 1 0 7 3 14 7 21 11 11 6 23 11 34 17 6 4 12 7 19 10 0 0 0 1 1 1 1 2 2 3 3 5 4 5 8 10 13 15 6 8 12 16 18 24 8 9 15 19 23 28 8 11 16 21 24 31 8 11 16 21 24 31 8 10 15 19 23 28 6 8 12 16 18 24 4 5 8 10 12 15 2 2 3 3 4 5 0 0 0 0 0 0-1 1-2 1-3 1-3 0-6 1-9 2-5 1-10 2-15 3-6 2-13 4-20 5-8 3-16 5-24 7-9 3-19 6-28 9-10 3-21 7-31 11-12 4-23 8-34 13-12 5-24 10-36 15-13 6-26 12-38 18-13 7-26 14-39 21-13 7-27 15-39 23-14 9-27 17-40 27-13 9-26 19-39 29-13 11-25 22-37 33-13 11-25 23-36 36-12 13-23 26-34 40-11 14-21 28-31 43-9 15-19 31-27 47 0 1 0 1 0 1z m-3 3c-1-5-3-9-4-14-3-10-7-21-10-32-4-12-8-25-12-37-3-10-6-20-9-30-1-3-2-6-3-8 0-1 0-2 0-2 1-5 3-10 5-15 3-10 6-20 10-30 4-12 8-24 12-37 4-12 8-24 12-36 3-9 6-18 9-26 1-3 1-5 2-8 0 0 1-1 1-2 2-4 5-8 7-12 5-10 10-19 15-28 6-11 12-23 19-34 6-11 12-22 18-33 4-8 8-15 12-23 1-2 2-4 4-6 4-5 8-9 13-14 7-8 15-16 23-24 9-10 18-20 26-29 9-9 17-18 25-26 5-6 10-11 15-17 2-1 3-3 5-5 5-5 11-11 17-17 9-8 17-17 26-26 9-9 18-18 27-27 7-7 14-14 21-21 2-2 3-3 5-5 0 0 1-1 1-1 0 0 1 0 1 0 11 2 22 3 32 5 9 1 17 2 26 3 0 0 1 1 1 1 1 1 2 3 4 4 4 5 9 10 13 15 7 8 14 15 20 22 9 9 17 18 25 27 9 10 18 20 27 30 8 9 17 19 26 29 8 9 16 17 24 26 7 7 13 15 20 22 4 5 8 9 13 14 1 1 2 2 3 3 0 1 1 1 1 1 0 1-3 1-3 1-3 1-7 2-10 3-4 2-9 3-14 5-6 2-13 4-19 6-8 3-16 6-24 9-9 3-18 7-27 11-10 4-20 8-30 13-11 5-22 10-33 16-12 5-23 11-35 18-12 6-24 13-36 20-12 8-25 16-37 24-13 8-25 17-37 26-13 10-25 19-38 29-12 11-24 21-36 33-12 11-24 23-35 35-11 13-22 25-33 39-10 13-21 27-30 42-10 15-19 30-27 45-9 16-17 32-24 48z m-2 10c-1-4-2-8-3-11-1-10-3-19-5-29-2-12-5-25-7-37-3-13-5-26-8-39-1-10-3-20-5-30-1-5-2-10-3-15 0-1 0-1 0-2 1-3 2-5 3-8 3-9 7-19 10-29 4-12 9-25 13-37 4-11 8-22 11-33 2-5 4-11 6-16 0-1 1-2 1-2 1-3 2-5 4-7 4-9 8-18 13-27 6-12 11-23 17-35 6-11 11-22 17-33 3-7 7-14 11-21 0-2 1-3 1-4 1-1 2-1 2-2 5-6 9-11 14-17 8-9 15-18 22-27 9-10 17-20 26-30 7-9 15-18 22-27 5-6 10-11 15-17 0-1 1-2 2-3 0 0 0 0 0 0 1-1 2-1 3-2 7-4 14-9 21-14 10-7 21-14 31-22 11-7 21-14 31-20 6-4 12-9 18-13 3-2 7-5 10-8 10-8 19-16 29-24 7-5 13-11 20-17 1 0 1 0 1 1 1 1 2 2 3 3 4 4 8 8 12 13 6 6 12 13 18 20 8 8 16 17 23 25 9 10 18 19 26 29 9 9 18 19 27 29 9 9 18 19 26 28 8 9 16 17 23 26 6 6 13 13 19 20 4 4 7 8 11 12 1 2 3 3 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0-3 1-3 1-3 1-6 2-9 2-5 2-10 4-15 5-6 2-12 5-18 7-8 3-16 6-24 9-8 4-17 8-26 12-10 4-20 9-30 13-11 6-22 11-32 16-12 6-23 13-35 19-12 7-23 14-35 21-13 8-25 16-37 24-12 8-25 17-37 26-12 9-24 19-36 29-13 10-25 21-36 32-12 11-24 22-35 34-12 12-22 25-33 38-11 13-21 26-30 40-10 14-19 29-28 44-9 15-17 30-24 46-4 10-8 20-12 30z m696 21c-2 4-5 7-9 9-5 3-11 5-16 8-11 4-23 9-34 13-23 8-47 14-71 20-24 6-49 12-74 17-25 6-50 10-76 15-25 4-50 8-75 10-13 1-26 1-39 0-6-1-13-2-19-3-6-1-13-2-19-3-26-4-51-9-77-14-25-5-50-10-75-16-25-5-49-12-74-20-12-4-24-9-36-13-6-3-11-5-17-8-3-1-6-2-9-3-3-1-5-2-8-4-4-2-7-5-10-9-1-2-2-4-3-7-1-3-2-6-3-9-4-11-7-24-9-36-5-24-7-49-6-74 0-13 1-25 3-38 1-12 3-25 5-37 5-25 12-50 20-74 4-12 8-24 13-36 4-11 10-22 15-33 10-21 21-42 34-62 12-20 25-39 39-58 14-19 28-37 43-55 16-18 33-36 50-54 17-18 34-35 52-52 18-17 36-33 55-49 10-7 19-15 28-22 10-8 19-15 28-23 2-2 5-4 7-7 0 0 1-1 1-1 0 0 1 0 1 0 0 0 1 0 2 0 4 4 9 8 14 11 9 8 19 15 28 23 18 15 36 31 54 47 18 16 35 32 52 49 17 16 33 34 49 51 16 18 32 37 47 56 14 18 28 38 41 57 13 20 25 40 36 61 11 21 21 43 30 65 9 22 17 45 23 68 6 23 11 47 13 70 3 24 3 49 2 73 0 3-1 6-2 9 0 3-1 6-2 9-1 6-2 12-3 18-3 11-5 22-8 33-4 9-7 19-11 28-2 5 13-29 0 0z m-51-210c-7-25-15-49-26-73-9-22-19-44-30-64-12-21-24-40-37-59-13-19-27-38-42-56-15-18-31-36-47-54-17-18-34-36-52-53-18-17-37-34-56-50-9-7-19-15-28-23-1 0-2-1-2-1-1 0-2 0-2 0-1 0-2 1-2 1 0 0-1 1-1 1-2 1-3 3-4 4-4 3-9 7-14 11-2 1-4 3-7 5-2 2-4 4-6 6-5 4-9 8-14 13-9 8-18 17-27 25-10 9-18 18-27 27-4 4-8 9-13 13-4 4-8 9-12 13-17 17-33 35-49 53-15 18-30 37-44 57-14 20-27 40-38 61-12 21-23 42-32 64-10 22-18 45-25 67-2 6-4 12-5 19-1 6-2 12-3 19-2 13-4 26-4 39-1 13-2 26-1 39 0 12 1 25 3 37 0 4 0 7 1 10 0 1 0 3 0 5 1 1 1 3 1 4 0 3 1 5 2 7 0 2 0 3 0 4 0 1 1 2 2 3 1 0 2 1 3 2 0 0 1 0 1 1 1 0 2 0 3 1 3 1 6 2 9 3 6 2 12 5 18 7 23 8 47 16 72 23 12 3 24 6 37 9 6 1 12 2 18 4 7 1 13 2 19 4 26 5 51 9 77 13 13 1 26 3 39 5 3 0 7 1 10 1 1 1 3 1 4 1 2 0 3 0 4 0 6 0 12 0 17-1 1 0 2-1 4-1 1 0 3-1 4-1 3 0 6-1 9-1 7-1 13-2 19-3 13-2 25-4 38-6 25-4 51-8 76-13 25-6 50-12 75-19 12-4 24-8 37-12 6-2 12-4 18-6 3-1 6-2 9-3 1-1 3-1 4-2 1 0 1 0 2 0 1-1 2-1 2-1 2-2 3-2 4-4 1-1 1-1 1-2 0-1 0-2 0-2 1-1 1-2 1-3 2-6 3-13 4-19 1-7 2-13 3-20 0-3 0-6 0-9 0-1 0-2 0-2 0-1 0-2 0-3 1-1 1-3 1-5 5-23 7-48 5-72-1-13-3-26-6-38-8-29 8 35 0 0z m-197 0c-2 4-3 9-5 13 0 1 0 1 0 2-1 0 0 1-1 1 0 1 0 2 0 2 0 1-1 2-1 3-1 2-3 4-4 5-2 2-5 4-7 4 2 2 4 3 7 5 1 1 2 2 3 2 1 1 2 1 2 2 0 1 0 1 0 2 1 0 1 1 2 1 0 1 1 2 1 4 0 2 0 4 0 6 0 3 0 5 0 7 0 3 0 5-1 7-1 6-4 10-8 14-1 2-3 3-5 4-3 2-5 4-8 5-3 1-6 2-9 3-3 0-5 0-7 0-3 0-6 0-8 0-13 0-25 0-37 0-5 0-10 0-14 0-1 0-2 0-3 0 0 0 0-4 0-5 0-3 0-6 0-9 0-1 0-2 0-3 0-1 0-1 1-1 1 0 12 0 12 0 0-8 0-16 0-24 0-13 0-25 0-38 0-4 0-7 0-11 0 0 0-1 0-1-3 0-5 0-8 0-1 0-2 0-4 0 0 0-1 0-1-1 0-2 0-4 0-6 0-1 0-14 0-14 10 0 19 0 29 0 5 0 11 0 16 0 1 0 3 0 4 0 0 0 0 3 0 3 0 6 0 11 0 17 0 1 0 1-1 1-1 0-2 0-4 0-1 0-3 0-4 0 0 0-1-1-1 0 0 5 0 10 0 15 0 2 0 5 0 8 0 1 0 1 0 2 0 0 0 0 1 0 2 0 5 0 8 0 2 0 4 0 6 0 1 0 3 0 4 0 1 0 2-1 3-2 1-1 2-2 3-3 0-1 0-1 0-2 0-2 1-3 1-4 1-1 1-2 2-3 0-1 0-1 0-1 0-1 0-2 0-2 1-6 2-12 3-17 1-3 1-5 2-8 0 0 0-1 0-1 0 0 0 0 0 0 11 0 21 0 32 0 0 0 1 0 1 0 0 0 0 0 0 0 0 3 0 5 0 8 0 5 0 10 0 15 0 0 0 0 0 0-1-2-1-4-2-5z m-26 53c0-2-3-3-4-4-1 0-1-1-1-1 0 0-1 0-1 0 0 0-1 0-1 0-1-1-1-2-2-2-1 0-2 0-3 0-2 0-4 0-5 0-1 0-2 0-2 0-3 0-7 0-10 0 0 0-4 0-4 0 0 9 0 19 0 28 0 0 13 0 14 0 4 0 8 0 12-1 1 0 3-1 4-2 1 0 2-1 3-2 1-2 2-4 3-6 0-1 0-1 0-2-1-1-1-1-1-2-1-1-1-1-1-2-1-1-1-2-1-4z m131-53c0 9 0 18 0 27 0 9-2 18-8 24-7 7-19 8-28 7-2 0-4 0-6-1-1 0-1-1-2-2-1 0-2 0-2-1-3-1-6-3-8-6 0 9 0 18 0 27 0 6 0 12 0 18 0 2 0 3 0 5 0 1 0 1 0 1-11 0-22 0-32 0-1 0-3 0-4 0 0 0 0-4 0-4 0-5 0-11 0-16 0 0 1 0 1 0 1 0 3 0 4 0 3 0 5 0 8 0 0 0 0-5 0-6 0-11 0-23 0-34 0-11 0-22 0-33 0-1 0-2 0-3 0-1 0-1-1-1-3 0-6 0-9 0-1 0-2 0-3 0 0 0 0-1 0-1 0-6 0-11 0-17 0-1 0-1 0-2 0 0 0 0 0 0 2 0 3 0 4 0 12 0 24 0 36 0 0 0 9 0 9 0 0 5 0 10 0 15 0 1 0 3 0 5 0 0-6 0-7 0 0 0-6 0-6 0 0 1 0 3 0 4 0 6 0 12 0 18 0 3 0 5 0 7 0 1 0 1 0 2 0 0 1 1 2 2 1 1 2 2 3 2 1 1 1 1 2 1 1 0 1 0 1 1 2 1 3 1 4 1 3 1 5 0 7-1 1-1 2-2 3-3 1-1 2-2 2-3 1-2 1-4 1-6 0-3 0-7 0-11 0-11 0-22 0-33 0-1 0-2 1-2 1 0 3 0 5 0 6 0 12 0 19 0 3 0 7 0 11 0 0 0 0 14 0 15 0 2 0 4 0 6-2-1-5-2-7-2z m7 122c-2 0-5 0-7 0-1 0-2 0-3 0 0 0 0 0 0 0-3-5-7-10-10-14-1-2-3-5-4-7 0 0-1-1-1-2 0 0 0-1 0-1 0-1 0-4 0-4 0 0 1 0 2 0 3 0 5 0 8 0 3 0 5 0 8 0 0 0 0-1 0-1 0-1 0-3 0-4 0-2 0-3 0-4 0-1 0-1 1-1 1 0 3 0 4 0 1 0 2 0 2 0 0 3 0 6 0 8 0 1 0 2 1 2 1 0 2 0 4 0 0 0 0 0 0 0 0 1 0 1 0 2 0 0 0 3 0 3-1 0-2 0-3 0-1 0-2 0-2 1 0 7 0 15 0 22z m-7-15c0-1 0-2 0-4 0-1 0-1 0-2 0 0 0-1 0-2 0 0-1 0-1 0-1 0-2 0-3 0-1 0-3 0-4 0 1 2 3 4 4 6 1 1 1 2 2 3 1 2 2 4 2 7 0-3 0-5 0-8z m41-2c-3 2-8 2-11 2-1 0-2 0-2 0 0 0 0 1 0 1 0 2 0 3 0 4 0 0 13 0 14 0 1 0 1 0 1 1 0 1 0 2 0 4 0 1 0 2 0 3 0 0-1 0-1 0-6 0-11 0-17 0-1 0-1 0-2 0 0 0 0-1 0-1-1-2-1-4-1-6-1-5-1-9-2-14 4 0 9 1 12-1 3-1 4-4 4-7-1-4-5-4-7-4-2 0-9-1-9 2-1-2-1-5-2-8 1 0 3-1 5-1 2-1 5-1 7-1 4 0 8 2 11 5 2 3 2 7 2 11 0 2 0 5 0 7 0 1-1 2-2 3 0 0 0 0 0 0-3 2 2 0 0 0z" horiz-adv-x="1000" />
+
+<glyph glyph-name="up" unicode="&#xe832;" d="M687 254l-173 217c-8 9-22 9-29 0l-173-217c-9-12-1-29 15-29h345c16 0 24 17 15 29z" horiz-adv-x="1000" />
+
+<glyph glyph-name="merge" unicode="&#xe833;" d="M200 110c0-72 58-131 130-131s130 59 130 131c0 45-24 86-60 109 18 139 133 179 202 190v-301c-38-23-65-64-65-112 0-72 59-130 130-130s130 58 130 130c0 48-26 89-65 112v487c39 23 65 64 65 112 0 72-58 130-130 130s-130-58-130-130c0-48 27-89 65-112v-55c-60-8-162-32-238-108-54-54-86-124-94-208-42-22-70-65-70-114z m468-158c-24 0-44 20-44 43s20 44 44 44c24 0 43-20 43-44s-19-43-43-43z m0 798c24 0 43-19 43-43s-20-43-43-43c-24 0-44 19-44 43s20 43 44 43z m-338-684c-24 0-43 20-43 43s19 44 43 44c24 0 43-20 43-44s-19-43-43-43z" horiz-adv-x="1000" />
 </font>
 </defs>
 </svg>
  No newline at end of file

rhodecode/public/js/rhodecode/base/keyboard-bindings.js

@@ -1,6 +1,18 b''
 // Global keyboard bindings
 
 function setRCMouseBindings(repoName, repoLandingRev) {
+
+    /** custom callback for supressing mousetrap from firing */
+    Mousetrap.stopCallback = function(e, element) {
+        // if the element has the class "mousetrap" then no need to stop
+        if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
+            return false;
+        }
+
+        // stop for input, select, and textarea
+        return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;
+    };
+
     // general help "?"
     Mousetrap.bind(['?'], function(e) {
         $('#help_kb').modal({});

rhodecode/public/js/rhodecode/i18n/be.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Selection link',
+    'Send': 'Send',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Stop following this repository',
     'Submitting...': 'Submitting...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabled',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/de.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Selection link',
+    'Send': 'Senden',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Stop following this repository',
     'Submitting...': 'Submitting...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabled',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/en.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Selection link',
+    'Send': 'Send',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Stop following this repository',
     'Submitting...': 'Submitting...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabled',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/es.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Selection link',
+    'Send': 'Send',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Stop following this repository',
     'Submitting...': 'Submitting...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabled',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/fr.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Lien vers la sélection',
+    'Send': 'Envoyer',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Arrêter de suivre ce dépôt',
     'Submitting...': 'Envoi…',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'Désactivé',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/it.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Aggiungi un altro commento',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Segui',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Caricamento ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Collegamento selezione',
+    'Send': 'Invia',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Mostra ancora',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Smetti di seguire il repository',
     'Submitting...': 'Inoltro...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'Al momento non ci sono richieste di PULL che richiedono il tuo intervento',
     'Unfollow': 'Smetti di seguire',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabilitato',
     'enabled': 'abilitato',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/ja.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': '別のコメントを追加',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'フォロー',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': '読み込み中...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'セレクション・リンク',
+    'Send': '送信',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'もっと表示',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'このリポジトリのフォローをやめる',
     'Submitting...': '送信中...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'アンフォロー',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': '無効',
     'enabled': '有効',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/js_translations.js

@@ -1,7 +1,11 b''
 // AUTO GENERATED FILE FOR Babel JS-GETTEXT EXTRACTORS, DO NOT CHANGE
+_gettext('(from usergroup {0})');
 _gettext('Add another comment');
+_gettext('Close');
 _gettext('Comment text will be set automatically based on currently selected status ({0}) ...');
+_gettext('Delete this comment?');
 _gettext('Follow');
+_gettext('Invite reviewers to this discussion');
 _gettext('Loading ...');
 _gettext('Loading failed');
 _gettext('Loading more results...');
@@ -26,6 +30,7 b''
 _gettext('Please enter {0} or more characters');
 _gettext('Searching...');
 _gettext('Selection link');
+_gettext('Send');
 _gettext('Set status to Approved');
 _gettext('Set status to Rejected');
 _gettext('Show more');
@@ -35,10 +40,14 b''
 _gettext('Status Review');
 _gettext('Stop following this repository');
 _gettext('Submitting...');
+_gettext('Switch to chat');
+_gettext('Switch to comment');
+_gettext('There are currently no open pull requests requiring your participation.');
 _gettext('Unfollow');
 _gettext('Updating...');
 _gettext('You can only select {0} item');
 _gettext('You can only select {0} items');
+_gettext('added manually by "{0}"');
 _gettext('disabled');
 _gettext('enabled');
 _gettext('file');

rhodecode/public/js/rhodecode/i18n/pl.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Dodaj kolejny komentarz',
+    'Close': 'Zamknij',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Obserwuj',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Ładuję...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Wybór linku',
+    'Send': 'Wyślij',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Pokaż więcej',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Zakończyć obserwację tego repozytorium',
     'Submitting...': 'Przesyłanie...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Nie obserwuj',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'disabled',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/pt.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Adicionar outro comentário',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Seguir',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Carregando...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Link da seleção',
+    'Send': 'Enviar',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Mostrar mais',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Parar de seguir este repositório',
     'Submitting...': 'Enviando...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Parar de seguir',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'desabilitado',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/ru.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Добавить другой комментарий',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Наблюдать',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Загрузка...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': 'Ссылка выбора',
+    'Send': 'Отправить',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Показать еще',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': 'Отменить наблюдение за репозиторием',
     'Submitting...': 'Применение...',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Не наблюдать',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': 'отключено',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/i18n/zh.js

@@ -5,9 +5,13 b''
  */
 //JS translations map
 var _TM = {
+    '(from usergroup {0})': '(from usergroup {0})',
     'Add another comment': 'Add another comment',
+    'Close': 'Close',
     'Comment text will be set automatically based on currently selected status ({0}) ...': 'Comment text will be set automatically based on currently selected status ({0}) ...',
+    'Delete this comment?': 'Delete this comment?',
     'Follow': 'Follow',
+    'Invite reviewers to this discussion': 'Invite reviewers to this discussion',
     'Loading ...': 'Loading ...',
     'Loading failed': 'Loading failed',
     'Loading more results...': 'Loading more results...',
@@ -32,6 +36,7 b' var _TM = {'
     'Please enter {0} or more characters': 'Please enter {0} or more characters',
     'Searching...': 'Searching...',
     'Selection link': '选择链接',
+    'Send': '发送',
     'Set status to Approved': 'Set status to Approved',
     'Set status to Rejected': 'Set status to Rejected',
     'Show more': 'Show more',
@@ -41,10 +46,14 b' var _TM = {'
     'Status Review': 'Status Review',
     'Stop following this repository': '停止关注该版本库',
     'Submitting...': '提交中……',
+    'Switch to chat': 'Switch to chat',
+    'Switch to comment': 'Switch to comment',
+    'There are currently no open pull requests requiring your participation.': 'There are currently no open pull requests requiring your participation.',
     'Unfollow': 'Unfollow',
     'Updating...': 'Updating...',
     'You can only select {0} item': 'You can only select {0} item',
     'You can only select {0} items': 'You can only select {0} items',
+    'added manually by "{0}"': 'added manually by "{0}"',
     'disabled': '禁用',
     'enabled': 'enabled',
     'file': 'file',

rhodecode/public/js/rhodecode/routes.js

@@ -14,7 +14,9 b' function registerRCRoutes() {'
     // routes registration
     pyroutes.register('home', '/', []);
     pyroutes.register('user_autocomplete_data', '/_users', []);
+    pyroutes.register('user_group_autocomplete_data', '/_user_groups', []);
     pyroutes.register('new_repo', '/_admin/create_repository', []);
+    pyroutes.register('edit_user', '/_admin/users/%(user_id)s/edit', ['user_id']);
     pyroutes.register('edit_user_group_members', '/_admin/user_groups/%(user_group_id)s/edit/members', ['user_group_id']);
     pyroutes.register('gists', '/_admin/gists', []);
     pyroutes.register('new_gist', '/_admin/gists/new', []);
@@ -22,6 +24,7 b' function registerRCRoutes() {'
     pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']);
     pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']);
+    pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/default-reviewers', ['repo_name']);
     pyroutes.register('changeset_home', '/%(repo_name)s/changeset/%(revision)s', ['repo_name', 'revision']);
     pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
     pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']);

rhodecode/public/js/src/components/rhodecode-app/rhodecode-app.html

@@ -1,15 +1,18 b''
 <link rel="import" href="../../../../../../bower_components/polymer/polymer.html">
 <link rel="import" href="../channelstream-connection/channelstream-connection.html">
+<link rel="import" href="../rhodecode-toast/rhodecode-toast.html">
+<link rel="import" href="../rhodecode-favicon/rhodecode-favicon.html">
 
 <dom-module id="rhodecode-app">
     <template>
-        <rhodecode-toast id="notifications"></rhodecode-toast>
         <channelstream-connection
                 id="channelstream-connection"
                 on-channelstream-listen-message="receivedMessage"
                 on-channelstream-connected="handleConnected"
                 on-channelstream-subscribed="handleSubscribed">
         </channelstream-connection>
+        <rhodecode-favicon></rhodecode-favicon>
+        <rhodecode-toast id="notifications"></rhodecode-toast>
     </template>
     <script src="rhodecode-app.js"></script>
 </dom-module>

rhodecode/public/js/src/components/rhodecode-app/rhodecode-app.js

@@ -3,16 +3,20 b' ccLog.setLevel(Logger.OFF);'
 
 var rhodeCodeApp = Polymer({
     is: 'rhodecode-app',
-    created: function () {
+    attached: function () {
         ccLog.debug('rhodeCodeApp created');
         $.Topic('/notifications').subscribe(this.handleNotifications.bind(this));
-
-        $.Topic('/plugins/__REGISTER__').subscribe(
-            this.kickoffChannelstreamPlugin.bind(this)
-        );
-
+        $.Topic('/favicon/update').subscribe(this.faviconUpdate.bind(this));
         $.Topic('/connection_controller/subscribe').subscribe(
             this.subscribeToChannelTopic.bind(this));
+        // this event can be used to coordinate plugins to do their
+        // initialization before channelstream is kicked off
+        $.Topic('/__MAIN_APP__').publish({});
+
+        for (var i = 0; i < alertMessagePayloads.length; i++) {
+            $.Topic('/notifications').publish(alertMessagePayloads[i]);
+        }
+        this.kickoffChannelstreamPlugin();
     },
 
     /** proxy to channelstream connection */
@@ -24,6 +28,10 b' var rhodeCodeApp = Polymer({'
         this.$['notifications'].handleNotification(data);
     },
 
+    faviconUpdate: function (data) {
+        this.$$('rhodecode-favicon').counter = data.count;
+    },
+
     /** opens connection to ws server */
     kickoffChannelstreamPlugin: function (data) {
         ccLog.debug('kickoffChannelstreamPlugin');
@@ -33,7 +41,7 b' var rhodeCodeApp = Polymer({'
             channels.push(addChannels[i]);
         }
         if (window.CHANNELSTREAM_SETTINGS && CHANNELSTREAM_SETTINGS.enabled){
-            var channelstreamConnection = this.$['channelstream-connection'];
+            var channelstreamConnection = this.getChannelStreamConnection();
             channelstreamConnection.connectUrl = CHANNELSTREAM_URLS.connect;
             channelstreamConnection.subscribeUrl = CHANNELSTREAM_URLS.subscribe;
             channelstreamConnection.websocketUrl = CHANNELSTREAM_URLS.ws + '/ws';
@@ -61,7 +69,7 b' var rhodeCodeApp = Polymer({'
 
     /** subscribes users from channels in channelstream */
     subscribeToChannelTopic: function (channels) {
-        var channelstreamConnection = this.$['channelstream-connection'];
+        var channelstreamConnection = this.getChannelStreamConnection();
         var toSubscribe = channelstreamConnection.calculateSubscribe(channels);
         ccLog.debug('subscribeToChannelTopic', toSubscribe);
         if (toSubscribe.length > 0) {
@@ -96,7 +104,7 b' var rhodeCodeApp = Polymer({'
     },
 
     handleConnected: function (event) {
-        var channelstreamConnection = this.$['channelstream-connection'];
+        var channelstreamConnection = this.getChannelStreamConnection();
         channelstreamConnection.set('channelsState',
             event.detail.channels_info);
         channelstreamConnection.set('userState', event.detail.state);
@@ -104,7 +112,7 b' var rhodeCodeApp = Polymer({'
         this.propagageChannelsState();
     },
     handleSubscribed: function (event) {
-        var channelstreamConnection = this.$['channelstream-connection'];
+        var channelstreamConnection = this.getChannelStreamConnection();
         var channelInfo = event.detail.channels_info;
         var channelKeys = Object.keys(event.detail.channels_info);
         for (var i = 0; i < channelKeys.length; i++) {
@@ -116,7 +124,7 b' var rhodeCodeApp = Polymer({'
     },
     /** propagates channel states on topics */
     propagageChannelsState: function (event) {
-        var channelstreamConnection = this.$['channelstream-connection'];
+        var channelstreamConnection = this.getChannelStreamConnection();
         var channel_data = channelstreamConnection.channelsState;
         var channels = channelstreamConnection.channels;
         for (var i = 0; i < channels.length; i++) {

rhodecode/public/js/src/components/rhodecode-toast/rhodecode-toast.html

@@ -21,7 +21,7 b''
                 </template>
             </div>
             <div class="toast-close">
-                <button on-tap="dismissNotifications" class="btn btn-default">{{_gettext('Close now')}}</button>
+                <button on-tap="dismissNotifications" class="btn btn-default">{{_gettext('Close')}}</button>
             </div>
         </paper-toast>
     </template>

rhodecode/public/js/src/components/rhodecode-toast/rhodecode-toast.js

@@ -13,9 +13,11 b' Polymer({'
     ],
     _changedToasts: function(newValue, oldValue){
         this.$['p-toast'].notifyResize();
+        $.Topic('/favicon/update').publish({count: this.toasts.length});
     },
     dismissNotifications: function(){
         this.$['p-toast'].close();
+        $.Topic('/favicon/update').publish({count: 0});
     },
     handleClosed: function(){
         this.splice('toasts', 0);

rhodecode/public/js/src/components/shared-components.html

@@ -1,8 +1,9 b''
 <!-- required for stamped out templates that might use common elements  -->
+<link rel="import" href="rhodecode-legacy-js/rhodecode-legacy-js.html">
 <link rel="import" href="../../../../../bower_components/iron-ajax/iron-ajax.html">
 <link rel="import" href="shared-styles.html">
 <link rel="import" href="channelstream-connection/channelstream-connection.html">
-<link rel="import" href="rhodecode-app/rhodecode-app.html">
 <link rel="import" href="rhodecode-toast/rhodecode-toast.html">
 <link rel="import" href="rhodecode-toggle/rhodecode-toggle.html">
 <link rel="import" href="rhodecode-unsafe-html/rhodecode-unsafe-html.html">
+<link rel="import" href="rhodecode-app/rhodecode-app.html">

rhodecode/public/js/src/rhodecode.js

@@ -221,14 +221,32 b' var formatSelect2SelectionRefs = functio'
 };
 
 // takes a given html element and scrolls it down offset pixels
-function offsetScroll(element, offset){
-    setTimeout(function(){
+function offsetScroll(element, offset) {
+    setTimeout(function() {
         var location = element.offset().top;
         // some browsers use body, some use html
         $('html, body').animate({ scrollTop: (location - offset) });
     }, 100);
 }
 
+// scroll an element `percent`% from the top of page in `time` ms
+function scrollToElement(element, percent, time) {
+    percent = (percent === undefined ? 25 : percent);
+    time = (time === undefined ? 100 : time);
+
+    var $element = $(element);
+    var elOffset = $element.offset().top;
+    var elHeight = $element.height();
+    var windowHeight = $(window).height();
+    var offset = elOffset;
+    if (elHeight < windowHeight) {
+        offset = elOffset - ((windowHeight / (100 / percent)) - (elHeight / 2));
+    }
+    setTimeout(function() {
+        $('html, body').animate({ scrollTop: offset});
+    }, time);
+}
+
 /**
  * global hooks after DOM is loaded
  */
@@ -266,7 +284,36 b' function offsetScroll(element, offset){'
             }
         });
 
-    $('.compare_view_files').on(
+    $('body').on( /* TODO: replace the $('.compare_view_files').on('click') below
+                    when new diffs are integrated */
+        'click', '.cb-lineno a', function(event) {
+
+            if ($(this).attr('data-line-no') !== ""){
+                $('.cb-line-selected').removeClass('cb-line-selected');
+                var td = $(this).parent();
+                td.addClass('cb-line-selected'); // line number td
+                td.prev().addClass('cb-line-selected'); // line data td
+                td.next().addClass('cb-line-selected'); // line content td
+
+                // Replace URL without jumping to it if browser supports.
+                // Default otherwise
+                if (history.pushState) {
+                    var new_location = location.href.rstrip('#');
+                    if (location.hash) {
+                        new_location = new_location.replace(location.hash, "");
+                    }
+
+                    // Make new anchor url
+                    new_location = new_location + $(this).attr('href');
+                    history.pushState(true, document.title, new_location);
+
+                    return false;
+                }
+            }
+        });
+
+    $('.compare_view_files').on( /* TODO: replace this with .cb function above
+                                    when new diffs are integrated */
         'click', 'tr.line .lineno a',function(event) {
             if ($(this).text() != ""){
                 $('tr.line').removeClass('selected');
@@ -365,24 +412,63 b' function offsetScroll(element, offset){'
     // Select the line that comes from the url anchor
     // At the time of development, Chrome didn't seem to support jquery's :target
     // element, so I had to scroll manually
+
     if (location.hash) {
         var result = splitDelimitedHash(location.hash);
         var loc  = result.loc;
-        var remainder = result.remainder;
-        if (loc.length > 1){
-            var lineno = $(loc+'.lineno');
-            if (lineno.length > 0){
-                var tr = lineno.parents('tr.line');
-                tr.addClass('selected');
+        if (loc.length > 1) {
+
+            var highlightable_line_tds = [];
+
+            // source code line format
+            var page_highlights = loc.substring(
+                loc.indexOf('#') + 1).split('L');
 
-                tr[0].scrollIntoView();
+            if (page_highlights.length > 1) {
+                var highlight_ranges = page_highlights[1].split(",");
+                var h_lines = [];
+                for (var pos in highlight_ranges) {
+                    var _range = highlight_ranges[pos].split('-');
+                    if (_range.length === 2) {
+                        var start = parseInt(_range[0]);
+                        var end = parseInt(_range[1]);
+                        if (start < end) {
+                            for (var i = start; i <= end; i++) {
+                                h_lines.push(i);
+                            }
+                        }
+                    }
+                    else {
+                        h_lines.push(parseInt(highlight_ranges[pos]));
+                    }
+                }
+                for (pos in h_lines) {
+                    var line_td = $('td.cb-lineno#L' + h_lines[pos]);
+                    if (line_td.length) {
+                        highlightable_line_tds.push(line_td);
+                    }
+                }
+            }
 
+            // now check a direct id reference (diff page)
+            if ($(loc).length && $(loc).hasClass('cb-lineno')) {
+                highlightable_line_tds.push($(loc));
+            }
+            $.each(highlightable_line_tds, function (i, $td) {
+                $td.addClass('cb-line-selected'); // line number td
+                $td.prev().addClass('cb-line-selected'); // line data
+                $td.next().addClass('cb-line-selected'); // line content
+            });
+
+            if (highlightable_line_tds.length) {
+                var $first_line_td = highlightable_line_tds[0];
+                scrollToElement($first_line_td);
                 $.Topic('/ui/plugins/code/anchor_focus').prepareOrPublish({
-                    tr:tr,
-                    remainder:remainder});
+                    td: $first_line_td,
+                    remainder: result.remainder
+                });
             }
         }
     }
-
     collapsableContent();
 });

rhodecode/public/js/src/rhodecode/appenlight.js

@@ -26,6 +26,9 b' var initAppEnlight = function (config) {'
         if (config.requestInfo){
             AppEnlight.setRequestInfo(config.requestInfo);
         }
+        if (config.tags){
+            AppEnlight.addGlobalTags(config.tags);
+        }
     }
 };
 

rhodecode/public/js/src/rhodecode/codemirror.js

@@ -29,6 +29,178 b' cmLog.setLevel(Logger.OFF);'
 //global cache for inline forms
 var userHintsCache = {};
 
+// global timer, used to cancel async loading
+var CodeMirrorLoadUserHintTimer;
+
+var escapeRegExChars = function(value) {
+  return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+};
+
+/**
+ * Load hints from external source returns an array of objects in a format
+ * that hinting lib requires
+ * @returns {Array}
+ */
+var CodeMirrorLoadUserHints = function(query, triggerHints) {
+  cmLog.debug('Loading mentions users via AJAX');
+  var _users = [];
+  $.ajax({
+    type: 'GET',
+    data: {query: query},
+    url: pyroutes.url('user_autocomplete_data'),
+    headers: {'X-PARTIAL-XHR': true},
+    async: true
+  })
+  .done(function(data) {
+    var tmpl = '<img class="gravatar" src="{0}"/>{1}';
+    $.each(data.suggestions, function(i) {
+      var userObj = data.suggestions[i];
+
+      if (userObj.username !== "default") {
+        _users.push({
+          text: userObj.username + " ",
+          org_text: userObj.username,
+          displayText: userObj.value_display, // search that field
+          // internal caches
+          _icon_link: userObj.icon_link,
+          _text: userObj.value_display,
+
+          render: function(elt, data, completion) {
+            var el = document.createElement('div');
+            el.className = "CodeMirror-hint-entry";
+            el.innerHTML = tmpl.format(
+                completion._icon_link, completion._text);
+            elt.appendChild(el);
+          }
+        });
+      }
+    });
+    cmLog.debug('Mention users loaded');
+    // set to global cache
+    userHintsCache[query] = _users;
+    triggerHints(userHintsCache[query]);
+  })
+  .fail(function(data, textStatus, xhr) {
+    alert("error processing request: " + textStatus);
+  });
+};
+
+/**
+ * filters the results based on the current context
+ * @param users
+ * @param context
+ * @returns {Array}
+ */
+var CodeMirrorFilterUsers = function(users, context) {
+  var MAX_LIMIT = 10;
+  var filtered_users = [];
+  var curWord = context.string;
+
+  cmLog.debug('Filtering users based on query:', curWord);
+  $.each(users, function(i) {
+    var match = users[i];
+    var searchText = match.displayText;
+
+    if (!curWord ||
+        searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
+      // reset state
+      match._text = match.displayText;
+      if (curWord) {
+        // do highlighting
+        var pattern = '(' + escapeRegExChars(curWord) + ')';
+        match._text = searchText.replace(
+            new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
+      }
+
+      filtered_users.push(match);
+    }
+    // to not return to many results, use limit of filtered results
+    if (filtered_users.length > MAX_LIMIT) {
+      return false;
+    }
+  });
+
+  return filtered_users;
+};
+
+var CodeMirrorMentionHint = function(editor, callback, options) {
+  var cur = editor.getCursor();
+  var curLine = editor.getLine(cur.line).slice(0, cur.ch);
+
+  // match on @ +1char
+  var tokenMatch = new RegExp(
+      '(^@| @)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]*)$').exec(curLine);
+
+  var tokenStr = '';
+  if (tokenMatch !== null && tokenMatch.length > 0){
+    tokenStr = tokenMatch[0].strip();
+  } else {
+    // skip if we didn't match our token
+    return;
+  }
+
+  var context = {
+    start: (cur.ch - tokenStr.length) + 1,
+    end: cur.ch,
+    string: tokenStr.slice(1),
+    type: null
+  };
+
+  // case when we put the @sign in fron of a string,
+  // eg <@ we put it here>sometext then we need to prepend to text
+  if (context.end > cur.ch) {
+    context.start = context.start + 1; // we add to the @ sign
+    context.end = cur.ch; // don't eat front part just append
+    context.string = context.string.slice(1, cur.ch - context.start);
+  }
+
+  cmLog.debug('Mention context', context);
+
+  var triggerHints = function(userHints){
+    return callback({
+      list: CodeMirrorFilterUsers(userHints, context),
+      from: CodeMirror.Pos(cur.line, context.start),
+      to: CodeMirror.Pos(cur.line, context.end)
+    });
+  };
+
+  var queryBasedHintsCache = undefined;
+  // if we have something in the cache, try to fetch the query based cache
+  if (userHintsCache !== {}){
+    queryBasedHintsCache = userHintsCache[context.string];
+  }
+
+  if (queryBasedHintsCache !== undefined) {
+    cmLog.debug('Users loaded from cache');
+    triggerHints(queryBasedHintsCache);
+  } else {
+    // this takes care for async loading, and then displaying results
+    // and also propagates the userHintsCache
+    window.clearTimeout(CodeMirrorLoadUserHintTimer);
+    CodeMirrorLoadUserHintTimer = setTimeout(function() {
+      CodeMirrorLoadUserHints(context.string, triggerHints);
+    }, 300);
+  }
+};
+
+var CodeMirrorCompleteAfter = function(cm, pred) {
+  var options = {
+    completeSingle: false,
+    async: true,
+    closeOnUnfocus: true
+  };
+  var cur = cm.getCursor();
+  setTimeout(function() {
+    if (!cm.state.completionActive) {
+      cmLog.debug('Trigger mentions hinting');
+      CodeMirror.showHint(cm, CodeMirror.hint.mentions, options);
+    }
+  }, 100);
+
+  // tell CodeMirror we didn't handle the key
+  // trick to trigger on a char but still complete it
+  return CodeMirror.Pass;
+};
 
 var initCodeMirror = function(textAreadId, resetUrl, focus, options) {
   var ta = $('#' + textAreadId).get(0);
@@ -61,9 +233,6 b' var initCodeMirror = function(textAreadI'
 var initCommentBoxCodeMirror = function(textAreaId, triggerActions){
   var initialHeight = 100;
 
-  // global timer, used to cancel async loading
-  var loadUserHintTimer;
-
   if (typeof userHintsCache === "undefined") {
     userHintsCache = {};
     cmLog.debug('Init empty cache for mentions');
@@ -72,96 +241,6 b' var initCommentBoxCodeMirror = function('
     cmLog.debug('Element for textarea not found', textAreaId);
     return;
   }
-  var escapeRegExChars = function(value) {
-    return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
-  };
-  /**
-   * Load hints from external source returns an array of objects in a format
-   * that hinting lib requires
-   * @returns {Array}
-   */
-  var loadUserHints = function(query, triggerHints) {
-    cmLog.debug('Loading mentions users via AJAX');
-    var _users = [];
-    $.ajax({
-        type: 'GET',
-        data: {query: query},
-        url: pyroutes.url('user_autocomplete_data'),
-        headers: {'X-PARTIAL-XHR': true},
-        async: true
-    })
-    .done(function(data) {
-      var tmpl = '<img class="gravatar" src="{0}"/>{1}';
-      $.each(data.suggestions, function(i) {
-        var userObj = data.suggestions[i];
-
-        if (userObj.username !== "default") {
-          _users.push({
-            text: userObj.username + " ",
-            org_text: userObj.username,
-            displayText: userObj.value_display, // search that field
-            // internal caches
-            _icon_link: userObj.icon_link,
-            _text: userObj.value_display,
-
-            render: function(elt, data, completion) {
-              var el = document.createElement('div');
-              el.className = "CodeMirror-hint-entry";
-              el.innerHTML = tmpl.format(
-                  completion._icon_link, completion._text);
-              elt.appendChild(el);
-            }
-          });
-        }
-      });
-      cmLog.debug('Mention users loaded');
-      // set to global cache
-      userHintsCache[query] = _users;
-      triggerHints(userHintsCache[query]);
-    })
-    .fail(function(data, textStatus, xhr) {
-      alert("error processing request: " + textStatus);
-    });
-  };
-
-    /**
-     * filters the results based on the current context
-     * @param users
-     * @param context
-     * @returns {Array}
-     */
-    var filterUsers = function(users, context) {
-      var MAX_LIMIT = 10;
-      var filtered_users = [];
-      var curWord = context.string;
-
-      cmLog.debug('Filtering users based on query:', curWord);
-      $.each(users, function(i) {
-        var match = users[i];
-        var searchText = match.displayText;
-
-        if (!curWord ||
-          searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
-          // reset state
-          match._text = match.displayText;
-          if (curWord) {
-            // do highlighting
-            var pattern = '(' + escapeRegExChars(curWord) + ')';
-            match._text = searchText.replace(
-              new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
-          }
-
-            filtered_users.push(match);
-        }
-        // to not return to many results, use limit of filtered results
-        if (filtered_users.length > MAX_LIMIT) {
-          return false;
-        }
-      });
-
-      return filtered_users;
-    };
-
     /**
      * Filter action based on typed in text
      * @param actions
@@ -200,25 +279,6 b' var initCommentBoxCodeMirror = function('
       return filtered_actions;
     };
 
-    var completeAfter = function(cm, pred) {
-      var options = {
-        completeSingle: false,
-        async: true,
-        closeOnUnfocus: true
-      };
-        var cur = cm.getCursor();
-      setTimeout(function() {
-        if (!cm.state.completionActive) {
-          cmLog.debug('Trigger mentions hinting');
-          CodeMirror.showHint(cm, CodeMirror.hint.mentions, options);
-        }
-      }, 100);
-
-      // tell CodeMirror we didn't handle the key
-      // trick to trigger on a char but still complete it
-      return CodeMirror.Pass;
-    };
-
     var submitForm = function(cm, pred) {
       $(cm.display.input.textarea.form).submit();
       return CodeMirror.Pass;
@@ -238,7 +298,7 b' var initCommentBoxCodeMirror = function('
     };
 
     var extraKeys = {
-      "'@'": completeAfter,
+      "'@'": CodeMirrorCompleteAfter,
       Tab: function(cm) {
         // space indent instead of TABS
         var spaces = new Array(cm.getOption("indentUnit") + 1).join(" ");
@@ -285,66 +345,6 b' var initCommentBoxCodeMirror = function('
       self.setSize(null, height);
     });
 
-    var mentionHint = function(editor, callback, options) {
-      var cur = editor.getCursor();
-      var curLine = editor.getLine(cur.line).slice(0, cur.ch);
-
-      // match on @ +1char
-      var tokenMatch = new RegExp(
-          '(^@| @)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]*)$').exec(curLine);
-
-      var tokenStr = '';
-      if (tokenMatch !== null && tokenMatch.length > 0){
-        tokenStr = tokenMatch[0].strip();
-      } else {
-        // skip if we didn't match our token
-        return;
-      }
-
-      var context = {
-        start: (cur.ch - tokenStr.length) + 1,
-        end: cur.ch,
-        string: tokenStr.slice(1),
-        type: null
-      };
-
-      // case when we put the @sign in fron of a string,
-      // eg <@ we put it here>sometext then we need to prepend to text
-      if (context.end > cur.ch) {
-        context.start = context.start + 1; // we add to the @ sign
-        context.end = cur.ch; // don't eat front part just append
-        context.string = context.string.slice(1, cur.ch - context.start);
-      }
-
-      cmLog.debug('Mention context', context);
-
-      var triggerHints = function(userHints){
-        return callback({
-          list: filterUsers(userHints, context),
-          from: CodeMirror.Pos(cur.line, context.start),
-          to: CodeMirror.Pos(cur.line, context.end)
-        });
-      };
-
-      var queryBasedHintsCache = undefined;
-      // if we have something in the cache, try to fetch the query based cache
-      if (userHintsCache !== {}){
-        queryBasedHintsCache = userHintsCache[context.string];
-      }
-
-      if (queryBasedHintsCache !== undefined) {
-        cmLog.debug('Users loaded from cache');
-        triggerHints(queryBasedHintsCache);
-      } else {
-        // this takes care for async loading, and then displaying results
-        // and also propagates the userHintsCache
-        window.clearTimeout(loadUserHintTimer);
-        loadUserHintTimer = setTimeout(function() {
-            loadUserHints(context.string, triggerHints);
-        }, 300);
-      }
-    };
-
     var actionHint = function(editor, options) {
       var cur = editor.getCursor();
       var curLine = editor.getLine(cur.line).slice(0, cur.ch);
@@ -408,7 +408,7 b' var initCommentBoxCodeMirror = function('
         to: CodeMirror.Pos(cur.line, context.end)
       };
     };
-    CodeMirror.registerHelper("hint", "mentions", mentionHint);
+    CodeMirror.registerHelper("hint", "mentions", CodeMirrorMentionHint);
     CodeMirror.registerHelper("hint", "actions", actionHint);
     return cm;
 };

rhodecode/public/js/src/rhodecode/comments.js

@@ -323,7 +323,7 b' var bindToggleButtons = function() {'
 };
 
 var linkifyComments = function(comments) {
-
+  /* TODO: dan: remove this - it should no longer needed */
   for (var i = 0; i < comments.length; i++) {
     var comment_id = $(comments[i]).data('comment-id');
     var prev_comment_id = $(comments[i - 1]).data('comment-id');
@@ -347,7 +347,7 b' var linkifyComments = function(comments)'
   }
 
 };
-  
+
 /**
  * Iterates over all the inlines, and places them inside proper blocks of data
  */
@@ -670,3 +670,226 b' var CommentForm = (function() {'
 
     return CommentForm;
 })();
+
+var CommentsController = function() { /* comments controller */
+  var self = this;
+
+  this.cancelComment = function(node) {
+      var $node = $(node);
+      var $td = $node.closest('td');
+      $node.closest('.comment-inline-form').removeClass('comment-inline-form-open');
+      return false;
+  }
+  this.getLineNumber = function(node) {
+      var $node = $(node);
+      return $node.closest('td').attr('data-line-number');
+  }
+  this.scrollToComment = function(node, offset) {
+    if (!node) {
+      node = $('.comment-selected');
+      if (!node.length) {
+        node = $('comment-current')
+      }
+    }
+    $comment = $(node).closest('.comment-current');
+    $comments = $('.comment-current');
+
+    $('.comment-selected').removeClass('comment-selected');
+
+    var nextIdx = $('.comment-current').index($comment) + offset;
+    if (nextIdx >= $comments.length) {
+      nextIdx = 0;
+    }
+    var $next = $('.comment-current').eq(nextIdx);
+    var $cb = $next.closest('.cb');
+    $cb.removeClass('cb-collapsed')
+
+    var $filediffCollapseState = $cb.closest('.filediff').prev();
+    $filediffCollapseState.prop('checked', false);
+    $next.addClass('comment-selected');
+    scrollToElement($next);
+    return false;
+  }
+  this.nextComment = function(node) {
+    return self.scrollToComment(node, 1);
+  }
+  this.prevComment = function(node) {
+    return self.scrollToComment(node, -1);
+  }
+  this.deleteComment = function(node) {
+      if (!confirm(_gettext('Delete this comment?'))) {
+        return false;
+      }
+      var $node = $(node);
+      var $td = $node.closest('td');
+      var $comment = $node.closest('.comment');
+      var comment_id = $comment.attr('data-comment-id');
+      var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id);
+      var postData = {
+        '_method': 'delete',
+        'csrf_token': CSRF_TOKEN
+      };
+
+      $comment.addClass('comment-deleting');
+      $comment.hide('fast');
+
+      var success = function(response) {
+        $comment.remove();
+        return false;
+      };
+      var failure = function(data, textStatus, xhr) {
+        alert("error processing request: " + textStatus);
+        $comment.show('fast');
+        $comment.removeClass('comment-deleting');
+        return false;
+      };
+      ajaxPOST(url, postData, success, failure);
+  }
+  this.toggleComments = function(node, show) {
+    var $filediff = $(node).closest('.filediff');
+    if (show === true) {
+      $filediff.removeClass('hide-comments');
+    } else if (show === false) {
+      $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
+      $filediff.addClass('hide-comments');
+    } else {
+      $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
+      $filediff.toggleClass('hide-comments');
+    }
+    return false;
+  }
+  this.toggleLineComments = function(node) {
+    self.toggleComments(node, true);
+    var $node = $(node);
+    $node.closest('tr').toggleClass('hide-line-comments');
+  }
+  this.createComment = function(node) {
+      var $node = $(node);
+      var $td = $node.closest('td');
+      var $form = $td.find('.comment-inline-form');
+
+      if (!$form.length) {
+          var tmpl = $('#cb-comment-inline-form-template').html();
+          var $filediff = $node.closest('.filediff');
+          $filediff.removeClass('hide-comments');
+          var f_path = $filediff.attr('data-f-path');
+          var lineno = self.getLineNumber(node);
+          tmpl = tmpl.format(f_path, lineno);
+          $form = $(tmpl);
+
+          var $comments = $td.find('.inline-comments');
+          if (!$comments.length) {
+            $comments = $(
+              $('#cb-comments-inline-container-template').html());
+            $td.append($comments);
+          }
+
+          $td.find('.cb-comment-add-button').before($form);
+
+          var pullRequestId = templateContext.pull_request_data.pull_request_id;
+          var commitId = templateContext.commit_data.commit_id;
+          var _form = $form[0];
+          var commentForm = new CommentForm(_form, commitId, pullRequestId, lineno, false);
+          var cm = commentForm.getCmInstance();
+
+          // set a CUSTOM submit handler for inline comments.
+          commentForm.setHandleFormSubmit(function(o) {
+            var text = commentForm.cm.getValue();
+
+            if (text === "") {
+              return;
+            }
+
+            if (lineno === undefined) {
+              alert('missing line !');
+              return;
+            }
+            if (f_path === undefined) {
+              alert('missing file path !');
+              return;
+            }
+
+            var excludeCancelBtn = false;
+            var submitEvent = true;
+            commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
+            commentForm.cm.setOption("readOnly", true);
+            var postData = {
+                'text': text,
+                'f_path': f_path,
+                'line': lineno,
+                'csrf_token': CSRF_TOKEN
+            };
+            var submitSuccessCallback = function(json_data) {
+              $form.remove();
+              try {
+                var html = json_data.rendered_text;
+                var lineno = json_data.line_no;
+                var target_id = json_data.target_id;
+
+                $comments.find('.cb-comment-add-button').before(html);
+
+              } catch (e) {
+                console.error(e);
+              }
+
+
+              // re trigger the linkification of next/prev navigation
+              linkifyComments($('.inline-comment-injected'));
+              timeagoActivate();
+              bindDeleteCommentButtons();
+              commentForm.setActionButtonsDisabled(false);
+
+            };
+            var submitFailCallback = function(){
+                commentForm.resetCommentFormState(text)
+            };
+            commentForm.submitAjaxPOST(
+                commentForm.submitUrl, postData, submitSuccessCallback, submitFailCallback);
+          });
+
+          setTimeout(function() {
+              // callbacks
+              if (cm !== undefined) {
+                  cm.focus();
+              }
+          }, 10);
+
+            $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({
+                form: _form,
+                parent: $td[0],
+                lineno: lineno,
+                f_path: f_path}
+            );
+      }
+
+      $form.addClass('comment-inline-form-open');
+  }
+
+  this.renderInlineComments = function(file_comments) {
+    show_add_button = typeof show_add_button !== 'undefined' ? show_add_button : true;
+
+    for (var i = 0; i < file_comments.length; i++) {
+      var box = file_comments[i];
+
+      var target_id = $(box).attr('target_id');
+
+      // actually comments with line numbers
+      var comments = box.children;
+
+      for (var j = 0; j < comments.length; j++) {
+        var data = {
+          'rendered_text': comments[j].outerHTML,
+          'line_no': $(comments[j]).attr('line'),
+          'target_id': target_id
+        };
+      }
+    }
+
+    // since order of injection is random, we're now re-iterating
+    // from correct order and filling in links
+    linkifyComments($('.inline-comment-injected'));
+    bindDeleteCommentButtons();
+    firefoxAnchorFix();
+  };
+
+}
  No newline at end of file

rhodecode/public/js/src/rhodecode/pullrequests.js

@@ -32,7 +32,7 b' var removeReviewMember = function(review'
             var obj = $('#reviewer_{0}_name'.format(reviewer_id));
             obj.addClass('to-delete');
             // now delete the input
-            $('#reviewer_{0}_input'.format(reviewer_id)).remove();
+            $('#reviewer_{0} input'.format(reviewer_id)).remove();
         }
     }
     else{
@@ -40,23 +40,39 b' var removeReviewMember = function(review'
     }
 };
 
-var addReviewMember = function(id,fname,lname,nname,gravatar_link){
+var addReviewMember = function(id, fname, lname, nname, gravatar_link, reasons) {
     var members = $('#review_members').get(0);
+    var reasons_html = '';
+    var reasons_inputs = '';
+    var reasons = reasons || [];
+    if (reasons) {
+        for (var i = 0; i < reasons.length; i++) {
+            reasons_html += '<div class="reviewer_reason">- {0}</div>'.format(reasons[i]);
+            reasons_inputs += '<input type="hidden" name="reason" value="' + escapeHtml(reasons[i]) + '">';
+        }
+    }
     var tmpl = '<li id="reviewer_{2}">'+
+       '<input type="hidden" name="__start__" value="reviewer:mapping">'+
        '<div class="reviewer_status">'+
           '<div class="flag_status not_reviewed pull-left reviewer_member_status"></div>'+
        '</div>'+
       '<img alt="gravatar" class="gravatar" src="{0}"/>'+
       '<span class="reviewer_name user">{1}</span>'+
-      '<input type="hidden" value="{2}" name="review_members" />'+
+      reasons_html +
+      '<input type="hidden" name="user_id" value="{2}">'+
+       '<input type="hidden" name="__start__" value="reasons:sequence">'+
+       '{3}'+
+       '<input type="hidden" name="__end__" value="reasons:sequence">'+
       '<div class="reviewer_member_remove action_button" onclick="removeReviewMember({2})">' +
       '<i class="icon-remove-sign"></i>'+
         '</div>'+
     '</div>'+
+    '<input type="hidden" name="__end__" value="reviewer:mapping">'+
     '</li>' ;
+
     var displayname = "{0} ({1} {2})".format(
             nname, escapeHtml(fname), escapeHtml(lname));
-    var element = tmpl.format(gravatar_link,displayname,id);
+    var element = tmpl.format(gravatar_link,displayname,id,reasons_inputs);
     // check if we don't have this ID already in
     var ids = [];
     var _els = $('#review_members li').toArray();
@@ -74,7 +90,11 b' var _updatePullRequest = function(repo_n'
     var url = pyroutes.url(
         'pullrequest_update',
         {"repo_name": repo_name, "pull_request_id": pull_request_id});
-    postData.csrf_token = CSRF_TOKEN;
+    if (typeof postData === 'string' ) {
+        postData += '&csrf_token=' + CSRF_TOKEN;
+    } else {
+        postData.csrf_token = CSRF_TOKEN;
+    }
     var success = function(o) {
         window.location.reload();
     };
@@ -83,17 +103,9 b' var _updatePullRequest = function(repo_n'
 
 var updateReviewers = function(reviewers_ids, repo_name, pull_request_id){
     if (reviewers_ids === undefined){
-      var reviewers_ids = [];
-      var ids = $('#review_members input').toArray();
-      for(var i=0; i<ids.length;i++){
-          var id = ids[i].value
-          reviewers_ids.push(id);
-      }
+      var postData = '_method=put&' + $('#reviewers input').serialize();
+      _updatePullRequest(repo_name, pull_request_id, postData);
     }
-    var postData = {
-        '_method':'put',
-        'reviewers_ids': reviewers_ids};
-    _updatePullRequest(repo_name, pull_request_id, postData);
 };
 
 /**
@@ -197,8 +209,10 b' var ReviewerAutoComplete = function(inpu'
     formatResult: autocompleteFormatResult,
     lookupFilter: autocompleteFilterResult,
     onSelect: function(suggestion, data){
+      var msg = _gettext('added manually by "{0}"');
+      var reasons = [msg.format(templateContext.rhodecode_user.username)];
       addReviewMember(data.id, data.first_name, data.last_name,
-                      data.username, data.icon_link);
+                      data.username, data.icon_link, reasons);
       $('#'+input_id).val('');
     }
   });

rhodecode/public/js/src/rhodecode/utils/ajax.js

@@ -20,6 +20,9 b''
 * turns objects into GET query string
 */
 var toQueryString = function(o) {
+  if(typeof o === 'string') {
+    return o;
+  }
   if(typeof o !== 'object') {
     return false;
   }
@@ -33,18 +36,22 b' var toQueryString = function(o) {'
 /**
 * ajax call wrappers
 */
-var ajaxGET = function(url, success) {
+var ajaxGET = function(url, success, failure) {
   var sUrl = url;
   var request = $.ajax({url: sUrl, headers: {'X-PARTIAL-XHR': true}})
   .done(function(data){
     success(data);
   })
-  .fail(function(data, textStatus, xhr){
-    alert("error processing request: " + textStatus);
+  .fail(function(data, textStatus, xhr) {
+    if (failure) {
+      failure(data, textStatus, xhr);
+    } else {
+      alert("error processing request: " + textStatus);
+    }
   });
   return request;
 };
-var ajaxPOST = function(url,postData,success) {
+var ajaxPOST = function(url, postData, success, failure) {
   var sUrl = url;
   var postData = toQueryString(postData);
   var request = $.ajax({type: 'POST', data: postData, url: sUrl,
@@ -53,7 +60,11 b' var ajaxPOST = function(url,postData,suc'
     success(data);
   })
   .fail(function(data, textStatus, xhr){
-    alert("error processing request: " + textStatus);
+    if (failure) {
+      failure(data, textStatus, xhr);
+    } else {
+      alert("error processing request: " + textStatus);
+    }
   });
   return request;
 };

rhodecode/public/js/topics_list.txt

@@ -1,3 +1,4 b''
+/__MAIN_APP__ - launched when rhodecode-app element is attached to DOM
 /plugins/__REGISTER__ - launched after the onDomReady() code from rhodecode.js is executed
 /ui/plugins/code/anchor_focus - launched when rc starts to scroll on load to anchor on PR/Codeview
 /ui/plugins/code/comment_form_built - launched when injectInlineForm() is executed and the form object is created
@@ -5,3 +6,4 b''
 /connection_controller/subscribe - subscribes user to new channels
 /connection_controller/presence - receives presence change messages
 /connection_controller/channel_update - receives channel states
+/favicon/update - notify state change for favicon

rhodecode/rcserver.py

@@ -15,7 +15,7 b' import logging'
 import optparse
 import os
 import re
-import subprocess
+import subprocess32
 import sys
 import textwrap
 import threading
@@ -32,9 +32,9 b' from rhodecode.lib.compat import kill'
 
 
 def make_web_build_callback(filename):
-    p = subprocess.Popen('make web-build', shell=True,
-                         stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE,
+    p = subprocess32.Popen('make web-build', shell=True,
+                         stdout=subprocess32.PIPE,
+                         stderr=subprocess32.PIPE,
                          cwd=os.path.dirname(os.path.dirname(__file__)))
     stdout, stderr = p.communicate()
     stdout = ''.join(stdout)
@@ -658,7 +658,7 b' class RcServerCommand(object):'
             try:
                 try:
                     _turn_sigterm_into_systemexit()
-                    proc = subprocess.Popen(args, env=new_environ)
+                    proc = subprocess32.Popen(args, env=new_environ)
                     exit_code = proc.wait()
                     proc = None
                 except KeyboardInterrupt:

rhodecode/subscribers.py

@@ -19,14 +19,21 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
+import logging
 import pylons
+import Queue
+import subprocess32
 
 from pyramid.i18n import get_localizer
 from pyramid.threadlocal import get_current_request
+from threading import Thread
 
 from rhodecode.translation import _ as tsf
 
 
+log = logging.getLogger(__name__)
+
+
 def add_renderer_globals(event):
     # Put pylons stuff into the context. This will be removed as soon as
     # migration to pyramid is finished.
@@ -68,3 +75,82 b' def scan_repositories_if_enabled(event):'
     if vcs_server_enabled and import_on_startup:
         repositories = ScmModel().repo_scan(get_rhodecode_base_path())
         repo2db_mapper(repositories, remove_obsolete=False)
+
+
+class Subscriber(object):
+    """
+    Base class for subscribers to the pyramid event system.
+    """
+    def __call__(self, event):
+        self.run(event)
+
+    def run(self, event):
+        raise NotImplementedError('Subclass has to implement this.')
+
+
+class AsyncSubscriber(Subscriber):
+    """
+    Subscriber that handles the execution of events in a separate task to not
+    block the execution of the code which triggers the event. It puts the
+    received events into a queue from which the worker process takes them in
+    order.
+    """
+    def __init__(self):
+        self._stop = False
+        self._eventq = Queue.Queue()
+        self._worker = self.create_worker()
+        self._worker.start()
+
+    def __call__(self, event):
+        self._eventq.put(event)
+
+    def create_worker(self):
+        worker = Thread(target=self.do_work)
+        worker.daemon = True
+        return worker
+
+    def stop_worker(self):
+        self._stop = False
+        self._eventq.put(None)
+        self._worker.join()
+
+    def do_work(self):
+        while not self._stop:
+            event = self._eventq.get()
+            if event is not None:
+                self.run(event)
+
+
+class AsyncSubprocessSubscriber(AsyncSubscriber):
+    """
+    Subscriber that uses the subprocess32 module to execute a command if an
+    event is received. Events are handled asynchronously.
+    """
+
+    def __init__(self, cmd, timeout=None):
+        super(AsyncSubprocessSubscriber, self).__init__()
+        self._cmd = cmd
+        self._timeout = timeout
+
+    def run(self, event):
+        cmd = self._cmd
+        timeout = self._timeout
+        log.debug('Executing command %s.', cmd)
+
+        try:
+            output = subprocess32.check_output(
+                cmd, timeout=timeout, stderr=subprocess32.STDOUT)
+            log.debug('Command finished %s', cmd)
+            if output:
+                log.debug('Command output: %s', output)
+        except subprocess32.TimeoutExpired as e:
+            log.exception('Timeout while executing command.')
+            if e.output:
+                log.error('Command output: %s', e.output)
+        except subprocess32.CalledProcessError as e:
+            log.exception('Error while executing command.')
+            if e.output:
+                log.error('Command output: %s', e.output)
+        except:
+            log.exception(
+                'Exception while executing command %s.', cmd)

rhodecode/svn_support/__init__.py

@@ -20,10 +20,16 b''
 
 import logging
 import os
+import shlex
 
-from rhodecode import events
-from rhodecode.lib.utils2 import str2bool
+# Do not use `from rhodecode import events` here, it will be overridden by the
+# events module in this package due to pythons import mechanism.
+from rhodecode.events import RepoGroupEvent
+from rhodecode.subscribers import AsyncSubprocessSubscriber
+from rhodecode.config.middleware import (
+    _bool_setting, _string_setting, _int_setting)
 
+from .events import ModDavSvnConfigChange
 from .subscribers import generate_config_subscriber
 from . import config_keys
 
@@ -36,34 +42,42 b' def includeme(config):'
     _sanitize_settings_and_apply_defaults(settings)
 
     if settings[config_keys.generate_config]:
-        config.add_subscriber(
-            generate_config_subscriber, events.RepoGroupEvent)
+        # Add subscriber to generate the Apache mod dav svn configuration on
+        # repository group events.
+        config.add_subscriber(generate_config_subscriber, RepoGroupEvent)
+
+        # If a reload command is set add a subscriber to execute it on
+        # configuration changes.
+        reload_cmd = shlex.split(settings[config_keys.reload_command])
+        if reload_cmd:
+            reload_timeout = settings[config_keys.reload_timeout] or None
+            reload_subscriber = AsyncSubprocessSubscriber(
+                cmd=reload_cmd, timeout=reload_timeout)
+            config.add_subscriber(reload_subscriber, ModDavSvnConfigChange)
 
 
 def _sanitize_settings_and_apply_defaults(settings):
     """
     Set defaults, convert to python types and validate settings.
     """
-    # Convert bool settings from string to bool.
-    settings[config_keys.generate_config] = str2bool(
-        settings.get(config_keys.generate_config, 'false'))
-    settings[config_keys.list_parent_path] = str2bool(
-        settings.get(config_keys.list_parent_path, 'true'))
+    _bool_setting(settings, config_keys.generate_config, 'false')
+    _bool_setting(settings, config_keys.list_parent_path, 'true')
+    _int_setting(settings, config_keys.reload_timeout, 10)
+    _string_setting(settings, config_keys.config_file_path, '', lower=False)
+    _string_setting(settings, config_keys.location_root, '/', lower=False)
+    _string_setting(settings, config_keys.reload_command, '', lower=False)
 
-    # Set defaults if key not present.
-    settings.setdefault(config_keys.config_file_path, None)
-    settings.setdefault(config_keys.location_root, '/')
-    settings.setdefault(config_keys.parent_path_root, None)
+    # Convert negative timeout values to zero.
+    if settings[config_keys.reload_timeout] < 0:
+        settings[config_keys.reload_timeout] = 0
 
-    # Append path separator to paths.
+    # Append path separator to location root.
     settings[config_keys.location_root] = _append_path_sep(
         settings[config_keys.location_root])
-    settings[config_keys.parent_path_root] = _append_path_sep(
-        settings[config_keys.parent_path_root])
 
     # Validate settings.
     if settings[config_keys.generate_config]:
-        assert settings[config_keys.config_file_path] is not None
+        assert len(settings[config_keys.config_file_path]) > 0
 
 
 def _append_path_sep(path):

rhodecode/svn_support/config_keys.py

@@ -25,4 +25,5 b" config_file_path = 'svn.proxy.config_fil"
 generate_config = 'svn.proxy.generate_config'
 list_parent_path = 'svn.proxy.list_parent_path'
 location_root = 'svn.proxy.location_root'
-parent_path_root = 'svn.proxy.parent_path_root'
+reload_command = 'svn.proxy.reload_cmd'
+reload_timeout = 'svn.proxy.reload_timeout'

rhodecode/svn_support/subscribers.py

@@ -18,14 +18,23 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import logging
+
 
 from .utils import generate_mod_dav_svn_config
 
 
+log = logging.getLogger(__name__)
+
+
 def generate_config_subscriber(event):
     """
     Subscriber to the `rhodcode.events.RepoGroupEvent`. This triggers the
     automatic generation of mod_dav_svn config file on repository group
     changes.
     """
-    generate_mod_dav_svn_config(event.request.registry.settings)
+    try:
+        generate_mod_dav_svn_config(event.request.registry)
+    except Exception:
+        log.exception(
+            'Exception while generating subversion mod_dav_svn configuration.')

rhodecode/svn_support/templates/mod-dav-svn.conf.mako

@@ -36,6 +36,9 b''
 # After changing this a stop and start of Apache is required (using restart
 # doesn't work).
 
+# fix https -> http downgrade with DAV. It requires an header downgrade for
+# https -> http reverse proxy to work properly
+RequestHeader edit Destination ^https: http: early
 
 <Location "${location_root|n}">
     # The mod_dav_svn module takes the username from the apache request object.

rhodecode/svn_support/tests/test_mod_dav_svn_config.py

@@ -19,15 +19,13 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
-import codecs
 import mock
+import pytest
 import re
-import shutil
-import tempfile
 
 from pyramid import testing
 
-from rhodecode.svn_support import config_keys, utils
+from rhodecode.svn_support import utils
 
 
 class TestModDavSvnConfig(object):
@@ -38,30 +36,12 b' class TestModDavSvnConfig(object):'
         config = testing.setUp()
         config.include('pyramid_mako')
 
-        # Temporary directory holding the generated config files.
-        cls.tempdir = tempfile.mkdtemp(suffix='pytest-mod-dav-svn')
-
         cls.location_root = u'/location/root/çµäö'
         cls.parent_path_root = u'/parent/path/çµäö'
-        cls._dummy_realm = u'Dummy Realm (äöüçµ)'
+        cls.realm = u'Dummy Realm (äöüçµ)'
 
     @classmethod
-    def teardown_class(cls):
-        testing.tearDown()
-        shutil.rmtree(cls.tempdir, ignore_errors=True)
-
-    @classmethod
-    def get_settings(cls):
-        config_file_path = tempfile.mkstemp(
-            suffix='mod-dav-svn.conf', dir=cls.tempdir)[1]
-        return {
-            config_keys.config_file_path: config_file_path,
-            config_keys.location_root: cls.location_root,
-            config_keys.list_parent_path: True,
-        }
-
-    @classmethod
-    def get_repo_groups(cls, count=1):
+    def get_repo_group_mocks(cls, count=1):
         repo_groups = []
         for num in range(0, count):
             full_path = u'/path/to/RepöGröúp-°µ {}'.format(num)
@@ -81,71 +61,37 b' class TestModDavSvnConfig(object):'
             location=self.location_root, group_path=group_path)
         assert len(re.findall(pattern, config)) == 1
 
-    @mock.patch('rhodecode.svn_support.utils.get_rhodecode_realm')
-    @mock.patch('rhodecode.svn_support.utils.RepoGroup')
-    def test_generate_mod_dav_svn_config(self, RepoGroupMock, GetRealmMock):
-        # Setup mock objects.
-        GetRealmMock.return_value = self._dummy_realm
-        num_groups = 3
-        RepoGroupMock.get_all_repo_groups.return_value = self.get_repo_groups(
-            count=num_groups)
-
-        # Execute the method under test.
-        settings = self.get_settings()
-        utils.generate_mod_dav_svn_config(
-            settings=settings, parent_path_root=self.parent_path_root)
-
-        # Read generated file.
-        path = settings[config_keys.config_file_path]
-        with codecs.open(path, 'r', encoding='utf-8') as f:
-            content = f.read()
-
+    def test_render_mod_dav_svn_config(self):
+        repo_groups = self.get_repo_group_mocks(count=10)
+        generated_config = utils._render_mod_dav_svn_config(
+            parent_path_root=self.parent_path_root,
+            list_parent_path=True,
+            location_root=self.location_root,
+            repo_groups=repo_groups,
+            realm=self.realm
+        )
         # Assert that one location directive exists for each repository group.
-        for group in self.get_repo_groups(count=num_groups):
-            self.assert_group_location_directive(content, group.full_path)
+        for group in repo_groups:
+            self.assert_group_location_directive(
+                generated_config, group.full_path)
 
         # Assert that the root location directive exists.
-        self.assert_root_location_directive(content)
-
-    @mock.patch('rhodecode.svn_support.utils.get_rhodecode_realm')
-    @mock.patch('rhodecode.svn_support.utils.RepoGroup')
-    def test_list_parent_path_on(self, RepoGroupMock, GetRealmMock):
-        # Setup mock objects.
-        GetRealmMock.return_value = self._dummy_realm
-        RepoGroupMock.get_all_repo_groups.return_value = self.get_repo_groups()
-
-        # Execute the method under test.
-        settings = self.get_settings()
-        settings[config_keys.list_parent_path] = True
-        utils.generate_mod_dav_svn_config(
-            settings=settings, parent_path_root=self.parent_path_root)
-
-        # Read generated file.
-        path = settings[config_keys.config_file_path]
-        with codecs.open(path, 'r', encoding='utf-8') as f:
-            content = f.read()
+        self.assert_root_location_directive(generated_config)
 
-        # Make assertions.
-        assert not re.search('SVNListParentPath\s+Off', content)
-        assert re.search('SVNListParentPath\s+On', content)
-
-    @mock.patch('rhodecode.svn_support.utils.get_rhodecode_realm')
-    @mock.patch('rhodecode.svn_support.utils.RepoGroup')
-    def test_list_parent_path_off(self, RepoGroupMock, GetRealmMock):
-        # Setup mock objects.
-        GetRealmMock.return_value = self._dummy_realm
-        RepoGroupMock.get_all_repo_groups.return_value = self.get_repo_groups()
+    @pytest.mark.parametrize('list_parent_path', [True, False])
+    def test_list_parent_path(self, list_parent_path):
+        generated_config = utils._render_mod_dav_svn_config(
+            parent_path_root=self.parent_path_root,
+            list_parent_path=list_parent_path,
+            location_root=self.location_root,
+            repo_groups=self.get_repo_group_mocks(count=10),
+            realm=self.realm
+        )
 
-        # Execute the method under test.
-        settings = self.get_settings()
-        settings[config_keys.list_parent_path] = False
-        utils.generate_mod_dav_svn_config(
-            settings=settings, parent_path_root=self.parent_path_root)
-
-        # Read generated file.
-        with open(settings[config_keys.config_file_path], 'r') as file_:
-            content = file_.read()
-
-        # Make assertions.
-        assert re.search('SVNListParentPath\s+Off', content)
-        assert not re.search('SVNListParentPath\s+On', content)
+        # Assert that correct configuration directive is present.
+        if list_parent_path:
+            assert not re.search('SVNListParentPath\s+Off', generated_config)
+            assert re.search('SVNListParentPath\s+On', generated_config)
+        else:
+            assert re.search('SVNListParentPath\s+Off', generated_config)
+            assert not re.search('SVNListParentPath\s+On', generated_config)

rhodecode/svn_support/utils.py

@@ -18,36 +18,44 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import codecs
 import logging
 import os
-
 from pyramid.renderers import render
 
-from rhodecode.lib.utils import get_rhodecode_realm
+from rhodecode.events import trigger
+from rhodecode.lib.utils import get_rhodecode_realm, get_rhodecode_base_path
 from rhodecode.model.db import RepoGroup
+
 from . import config_keys
+from .events import ModDavSvnConfigChange
 
 
 log = logging.getLogger(__name__)
 
 
-def generate_mod_dav_svn_config(settings):
+def generate_mod_dav_svn_config(registry):
     """
     Generate the configuration file for use with subversion's mod_dav_svn
     module. The configuration has to contain a <Location> block for each
     available repository group because the mod_dav_svn module does not support
     repositories organized in sub folders.
     """
+    settings = registry.settings
     config = _render_mod_dav_svn_config(
-        settings[config_keys.parent_path_root],
-        settings[config_keys.list_parent_path],
-        settings[config_keys.location_root],
-        RepoGroup.get_all_repo_groups())
+        parent_path_root=get_rhodecode_base_path(),
+        list_parent_path=settings[config_keys.list_parent_path],
+        location_root=settings[config_keys.location_root],
+        repo_groups=RepoGroup.get_all_repo_groups(),
+        realm=get_rhodecode_realm())
     _write_mod_dav_svn_config(config, settings[config_keys.config_file_path])
 
+    # Trigger an event on mod dav svn configuration change.
+    trigger(ModDavSvnConfigChange(), registry)
+
 
 def _render_mod_dav_svn_config(
-        parent_path_root, list_parent_path, location_root, repo_groups):
+        parent_path_root, list_parent_path, location_root, repo_groups, realm):
     """
     Render mod_dav_svn configuration to string.
     """
@@ -63,7 +71,7 b' def _render_mod_dav_svn_config('
         'parent_path_root': parent_path_root,
         'repo_group_paths': repo_group_paths,
         'svn_list_parent_path': list_parent_path,
-        'rhodecode_realm': get_rhodecode_realm(),
+        'rhodecode_realm': realm,
     }
 
     # Render the configuration template to string.
@@ -73,11 +81,7 b' def _render_mod_dav_svn_config('
 
 def _write_mod_dav_svn_config(config, filepath):
     """
-    Write mod_dav_svn config to file. Log on exceptions but do not raise.
+    Write mod_dav_svn config to file.
     """
-    try:
-        with open(filepath, 'w') as file_:
-            file_.write(config)
-    except Exception:
-        log.exception(
-            'Can not write mod_dav_svn configuration to "%s"', filepath)
+    with codecs.open(filepath, 'w', encoding='utf-8') as f:
+        f.write(config)

rhodecode/templates/admin/gists/edit.html

@@ -24,12 +24,6 b''
     </div>
 
     <div class="table">
-        <div id="edit_error" class="flash_msg" style="display:none;">
-            <div class="alert alert-warning">
-              ${h.literal(_('Gist was updated since you started editing. Copy your changes and click %(here)s to reload the new version.')
-                             % {'here': h.link_to('here',h.url('edit_gist', gist_id=c.gist.gist_access_id))})}
-            </div>
-        </div>
 
         <div id="files_data">
           ${h.secure_form(h.url('edit_gist', gist_id=c.gist.gist_access_id), method='post', id='eform')}
@@ -115,7 +109,6 b''
 <script>
   $('#update').on('click', function(e){
       e.preventDefault();
-
       // check for newer version.
       $.ajax({
         url: "${h.url('edit_gist_check_revision', gist_id=c.gist.gist_access_id)}",
@@ -126,8 +119,11 b''
         type: 'GET',
         success: function(data) {
           if(data.success === false){
-              $('#edit_error').show();
-              window.scrollTo(0,0);
+            message = '${h.literal(_('Gist was updated since you started editing. Copy your changes and click %(here)s to reload the new version.')
+              % {'here': h.link_to('here',h.url('edit_gist', gist_id=c.gist.gist_access_id))})}'
+            alertMessage = [{"message": {
+              "message": message, "force": "true", "level": "warning"}}];
+            $.Topic('/notifications').publish(alertMessage[0]);
           }
           else{
             $('#eform').submit();

rhodecode/templates/admin/my_account/my_account_notifications.html

@@ -53,23 +53,6 b''
         $('#live-notifications')[0].checked = event.detail.response;
     };
 
-    function checkBrowserStatus(){
-        var browserStatus = 'Unknown';
-
-        if (!("Notification" in window)) {
-            browserStatus = 'Not supported'
-        }
-        else if(Notification.permission === 'denied'){
-            browserStatus = 'Denied';
-            $('.flash_msg').append('<div class="alert alert-error">Notifications are blocked on browser level - you need to enable them in your browser settings.</div>')
-        }
-        else if(Notification.permission === 'granted'){
-            browserStatus = 'Allowed';
-        }
-
-        $('#browser-notification-status').text(browserStatus);
-    }
-
     ctrlr.testNotifications = function(event){
         var levels = ['info', 'error', 'warning', 'success'];
         var level = levels[Math.floor(Math.random()*levels.length)];

rhodecode/templates/admin/my_account/my_account_pullrequests.html

@@ -11,123 +11,12 b''
 </div>
 
 <div class="panel panel-default">
-  <div class="panel-heading">
-    <h3 class="panel-title">${_('Pull Requests You Opened')}: ${len(c.my_pull_requests)}</h3>
-  </div>
-  <div class="panel-body">
-    <div class="pullrequestlist">
-        %if c.my_pull_requests:
-        <table class="rctable">
-          <thead>
-            <th class="td-status"></th>
-            <th>${_('Target Repo')}</th>
-            <th>${_('Author')}</th>
-            <th></th>
-            <th>${_('Title')}</th>
-            <th class="td-time">${_('Last Update')}</th>
-            <th></th>
-          </thead>
-          %for pull_request in c.my_pull_requests:
-            <tr class="${'closed' if pull_request.is_closed() else ''} prwrapper">
-              <td class="td-status">
-                <div class="${'flag_status %s' % pull_request.calculated_review_status()} pull-left"></div>
-              </td>
-              <td class="truncate-wrap td-componentname">
-                <div class="truncate">
-                  ${h.link_to(pull_request.target_repo.repo_name,h.url('summary_home',repo_name=pull_request.target_repo.repo_name))}
-                </div>
-              </td>
-              <td class="user">
-                ${base.gravatar_with_user(pull_request.author.email, 16)}
-              </td>
-              <td class="td-message expand_commit" data-pr-id="m${pull_request.pull_request_id}" title="${_('Expand commit message')}">
-                <div class="show_more_col">
-                  <i class="show_more"></i>&nbsp;
-                </div>
-              </td>
-              <td class="mid td-description">
-                <div class="log-container truncate-wrap">
-                    <div class="message truncate" id="c-m${pull_request.pull_request_id}"><a href="${h.url('pullrequest_show',repo_name=pull_request.target_repo.repo_name,pull_request_id=pull_request.pull_request_id)}">#${pull_request.pull_request_id}: ${pull_request.title}</a>\
-                    %if pull_request.is_closed():
-                      &nbsp;(${_('Closed')})\
-                    %endif
-                    <br/>${pull_request.description}</div>
-                </div>
-              </td>
-              <td class="td-time">
-                ${h.age_component(pull_request.updated_on)}
-              </td>
-              <td class="td-action repolist_actions">
-                ${h.secure_form(url('pullrequest_delete', repo_name=pull_request.target_repo.repo_name, pull_request_id=pull_request.pull_request_id),method='delete')}
-                  ${h.submit('remove_%s' % pull_request.pull_request_id, _('Delete'),
-                  class_="btn btn-link btn-danger",onclick="return confirm('"+_('Confirm to delete this pull request')+"');")}
-                ${h.end_form()}
-              </td>
-            </tr>
-          %endfor
-        </table>
-       %else:
-        <h2><span class="empty_data">${_('You currently have no open pull requests.')}</span></h2>
-       %endif
+    <div class="panel-heading">
+        <h3 class="panel-title">${_('Pull Requests You Participate In')}: ${c.records_total_participate}</h3>
     </div>
-  </div>
-</div>
-
-<div class="panel panel-default">
-  <div class="panel-heading">
-    <h3 class="panel-title">${_('Pull Requests You Participate In')}: ${len(c.participate_in_pull_requests)}</h3>
-  </div>
-
-  <div class="panel-body">
-    <div class="pullrequestlist">
-        %if c.participate_in_pull_requests:
-        <table class="rctable">
-          <thead>
-            <th class="td-status"></th>
-            <th>${_('Target Repo')}</th>
-            <th>${_('Author')}</th>
-            <th></th>
-            <th>${_('Title')}</th>
-            <th class="td-time">${_('Last Update')}</th>
-          </thead>
-          %for pull_request in c.participate_in_pull_requests:
-            <tr class="${'closed' if pull_request.is_closed() else ''} prwrapper">
-              <td class="td-status">
-                <div class="${'flag_status %s' % pull_request.calculated_review_status()} pull-left"></div>
-              </td>
-              <td class="truncate-wrap td-componentname">
-                <div class="truncate">
-                  ${h.link_to(pull_request.target_repo.repo_name,h.url('summary_home',repo_name=pull_request.target_repo.repo_name))}
-                </div>
-              </td>
-              <td class="user">
-                ${base.gravatar_with_user(pull_request.author.email, 16)}
-              </td>
-              <td class="td-message expand_commit" data-pr-id="p${pull_request.pull_request_id}" title="${_('Expand commit message')}">
-                <div class="show_more_col">
-                  <i class="show_more"></i>&nbsp;
-                </div>
-              </td>
-              <td class="mid td-description">
-                <div class="log-container truncate-wrap">
-                    <div class="message truncate" id="c-p${pull_request.pull_request_id}"><a href="${h.url('pullrequest_show',repo_name=pull_request.target_repo.repo_name,pull_request_id=pull_request.pull_request_id)}">#${pull_request.pull_request_id}: ${pull_request.title}</a>\
-                    %if pull_request.is_closed():
-                      &nbsp;(${_('Closed')})\
-                    %endif
-                    <br/>${pull_request.description}</div>
-                </div>
-              </td>
-              <td class="td-time">
-                ${h.age_component(pull_request.updated_on)}
-              </td>
-            </tr>
-          %endfor
-        </table>
-        %else:
-         <h2 class="empty_data">${_('There are currently no open pull requests requiring your participation.')}</h2>
-        %endif
+    <div class="panel-body">
+        <table id="pull_request_list_table_participate" class="display"></table>
     </div>
-  </div>
 </div>
 
 <script>
@@ -139,17 +28,51 b''
             window.location = "${h.url('my_account_pullrequests')}";
         }
     });
-    $('.expand_commit').on('click',function(e){
-      var target_expand = $(this);
-      var cid = target_expand.data('prId');
+    $(document).ready(function() {
+
+        var columnsDefs = [
+             { data: {"_": "status",
+                      "sort": "status"}, title: "", className: "td-status", orderable: false},
+             { data: {"_": "target_repo",
+                      "sort": "target_repo"}, title: "${_('Target Repo')}", className: "td-targetrepo", orderable: false},
+             { data: {"_": "name",
+                      "sort": "name_raw"}, title: "${_('Name')}", className: "td-componentname", "type": "num" },
+             { data: {"_": "author",
+                      "sort": "author_raw"}, title: "${_('Author')}", className: "td-user", orderable: false },
+             { data: {"_": "title",
+                      "sort": "title"}, title: "${_('Title')}", className: "td-description" },
+             { data: {"_": "comments",
+                      "sort": "comments_raw"}, title: "", className: "td-comments", orderable: false},
+             { data: {"_": "updated_on",
+                      "sort": "updated_on_raw"}, title: "${_('Last Update')}", className: "td-time" }
+        ];
 
-      if (target_expand.hasClass('open')){
-        $('#c-'+cid).css({'height': '2.75em', 'text-overflow': 'ellipsis', 'overflow':'hidden'});
-        target_expand.removeClass('open');
-      }
-      else {
-        $('#c-'+cid).css({'height': 'auto', 'text-overflow': 'initial', 'overflow':'visible'});
-        target_expand.addClass('open');
-      }
+        // participating object list
+        $('#pull_request_list_table_participate').DataTable({
+          data: ${c.data_participate|n},
+          processing: true,
+          serverSide: true,
+          deferLoading: ${c.records_total_participate},
+          ajax: "",
+          dom: 'tp',
+          pageLength: ${c.visual.dashboard_items},
+          order: [[ 2, "desc" ]],
+          columns: columnsDefs,
+          language: {
+                paginate: DEFAULT_GRID_PAGINATION,
+                emptyTable: _gettext("There are currently no open pull requests requiring your participation.")
+          },
+          "drawCallback": function( settings, json ) {
+              timeagoActivate();
+          },
+          "createdRow": function ( row, data, index ) {
+              if (data['closed']) {
+                $(row).addClass('closed');
+              }
+              if (data['owned']) {
+                $(row).addClass('owned');
+              }
+          }
+        });
     });
 </script>

rhodecode/templates/admin/permissions/permissions_application.html

@@ -29,6 +29,15 b''
                     </div>
 
                     <div class="field">
+                        <div class="label label-select">
+                            <label for="default_password_reset">${_('Password Reset')}:</label>
+                        </div>
+                        <div class="select">
+                            ${h.select('default_password_reset','',c.password_reset_choices)}
+                        </div>
+                    </div>
+
+                    <div class="field">
                         <div class="label label-textarea">
                             <label for="default_register_message">${_('Registration Page Message')}:</label>
                         </div>
@@ -66,6 +75,7 b''
         };
 
         $("#default_register").select2(select2Options);
+        $("#default_password_reset").select2(select2Options);
         $("#default_extern_activate").select2(select2Options);
     });
 </script>

rhodecode/templates/admin/repo_groups/repo_group_edit_advanced.html

@@ -4,6 +4,7 b''
  elems = [
     (_('Owner'), lambda:base.gravatar_with_user(c.repo_group.user.email), '', ''),
     (_('Created on'), h.format_date(c.repo_group.created_on), '', ''),
+    (_('Is Personal Group'), c.repo_group.personal or False, '', ''),
 
     (_('Total repositories'), c.repo_group.repositories_recursive_count, '', ''),
     (_('Top level repositories'), c.repo_group.repositories.count(), '', c.repo_group.repositories.all()),

rhodecode/templates/admin/repos/repo_add_base.html

@@ -42,9 +42,11 b''
              </div>
              <div class="select">
                  ${h.select('repo_group',request.GET.get('parent_group'),c.repo_groups,class_="medium")}
-                 %if c.personal_repo_group:
-                     <a style="padding: 4px" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}</a>
-                 %endif
+                 % if c.personal_repo_group:
+                     <a class="btn" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">
+                         ${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}
+                     </a>
+                 % endif
                  <span class="help-block">${_('Optionally select a group to put this repository into.')}</span>
              </div>
         </div>

rhodecode/templates/admin/repos/repo_creating.html

@@ -1,10 +1,6 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
-## don't trigger flash messages on this page
-<%def name="flash_msg()">
-</%def>
-
 <%def name="title()">
     ${_('%s Creating repository') % c.repo_name}
     %if c.rhodecode_name:

rhodecode/templates/admin/repos/repo_edit.html

@@ -71,6 +71,22 b''
           <li class="${'active' if c.active=='integrations' else ''}">
               <a href="${h.route_path('repo_integrations_home', repo_name=c.repo_name)}">${_('Integrations')}</a>
           </li>
+          ## TODO: dan: replace repo navigation with navlist registry like with
+          ## admin menu. First must find way to allow runtime configuration
+          ## it to account for the c.repo_info.repo_type != 'svn' call above
+          <%
+          reviewer_settings = False
+          try:
+            import rc_reviewers
+            reviewer_settings = True
+          except ImportError:
+            pass
+          %>
+          %if reviewer_settings:
+          <li class="${'active' if c.active=='reviewers' else ''}">
+              <a href="${h.route_path('repo_reviewers_home', repo_name=c.repo_name)}">${_('Reviewers')}</a>
+          </li>
+          %endif
         </ul>
     </div>
 

rhodecode/templates/admin/repos/repo_edit_settings.html

@@ -57,9 +57,11 b''
                 </div>
                 <div class="select">
                     ${h.select('repo_group','',c.repo_groups,class_="medium")}
-                     %if c.personal_repo_group:
-                         <a style="padding: 4px" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}</a>
-                     %endif
+                    % if c.personal_repo_group:
+                         <a class="btn" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">
+                             ${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}
+                         </a>
+                    % endif
                     <p class="help-block">${_('Optional select a group to put this repository into.')}</p>
                 </div>
             </div>

rhodecode/templates/admin/settings/settings_global.html

@@ -30,6 +30,35 b''
     </div>
 </div>
 
+
+<div class="panel panel-default">
+    <div class="panel-heading" id="personal-group-options">
+        <h3 class="panel-title">${_('Personal Repository Group')} <a class="permalink" href="#personal-group-options"> ¶</a></h3>
+    </div>
+    <div class="panel-body">
+        <div class="checkbox">
+            ${h.checkbox('rhodecode_create_personal_repo_group','True')}
+            <label for="rhodecode_create_personal_repo_group">${_('Create Personal Repository Group')}</label>
+        </div>
+        <span class="help-block">
+            ${_('Always create Personal Repository Groups for new users.')} <br/>
+            ${_('When creating new users from add user form or API you can still turn this off via a checkbox or flag')}
+        </span>
+
+        <div class="label">
+            <label for="rhodecode_personal_repo_group_pattern">${_('Personal Repo Group Pattern')}</label>
+        </div>
+        <div class="field input">
+            ${h.text('rhodecode_personal_repo_group_pattern',size=60, placeholder=c.personal_repo_group_default_pattern)}
+        </div>
+        <span class="help-block">
+            ${_('Pattern used to create Personal Repository Groups. Prefix can be other existing repository group path[s], eg. /u/${username}')} <br/>
+            ${_('Available variables are currently ${username} and ${user_id}')}
+        </span>
+    </div>
+</div>
+
+
 <div class="panel panel-default">
     <div class="panel-heading" id="captcha-options">
         <h3 class="panel-title">${_('Registration Captcha')} <a class="permalink" href="#captcha-options"> ¶</a></h3>
@@ -72,6 +101,7 b''
                 <option value="ga">Google Analytics</option>
                 <option value="clicky">Clicky</option>
                 <option value="server_announce">${_('Server Announcement')}</option>
+                <option value="flash_filtering">${_('Flash message filtering')}</option>
             </select>
         </div>
         <div style="padding: 10px 0px"></div>
@@ -183,20 +213,40 b''
 // important messages to all users of the RhodeCode Enterprise system.
 
 $(document).ready(function(e){
- // put your message below
+
+ // EDIT - put your message below
  var message = "TYPE YOUR MESSAGE HERE";
 
- $('#body').prepend(
-  ('<div class="flash_msg">'+
-   '<div class="alert alert-info">_MSG_'+
-   '</div></div>').replace('_MSG_', message)
+ // EDIT - choose "info"/"warning"/"error"/"success"/"neutral" as appropriate
+ var alert_level = "info";
+
+ $("#body").prepend(
+  ("<div id='server-announcement' class='"+alert_level+"'>_MSG_"+"</div>").replace("_MSG_", message)
  )
 })
 </script>
 </%text>
 </script>
 
+<script id="flash_filtering_tmpl" type='text/x-template'>
+<%text filter="h">
+<script>
+    // This filters out some flash messages before they are presented to user
+    // based on their contents. Could be used to filter out warnings/errors
+    // of license messages
 
+    var filteredMessages = [];
+    for(var i =0; i< alertMessagePayloads.length; i++){
+        if (typeof alertMessagePayloads[i].message.subdata.subtype !== 'undefined' &&
+                alertMessagePayloads[i].message.subdata.subtype.indexOf('rc_license') !== -1){
+            continue
+        }
+        filteredMessages.push(alertMessagePayloads[i]);
+    }
+    alertMessagePayloads = filteredMessages;
+</script>
+</%text>
+</script>
 
 <script>
 var pre_cm = initCodeMirror('rhodecode_pre_code', '', false);
@@ -215,7 +265,8 b' var get_data = function(type, old){'
         '#': old,
         'ga': get_tmpl('ga'),
         'clicky': get_tmpl('clicky'),
-        'server_announce': get_tmpl('server_announce')
+        'server_announce': get_tmpl('server_announce'),
+        'flash_filtering': get_tmpl('flash_filtering')
     }[type]
 };
 

rhodecode/templates/admin/settings/settings_system.html

@@ -1,41 +1,3 b''
-<%
- elems = [
-    ## general
-    (_('RhodeCode Enterprise version'), h.literal('%s <div class="link" id="check_for_update" >%s</div>' % (c.rhodecode_version, _('check for updates'))), ''),
-    (_('Upgrade info endpoint'), h.literal('%s <br/><span >%s.</span>' % (c.rhodecode_update_url, _('Note: please make sure this server can access this url'))), ''),
-    (_('Configuration INI file'), c.rhodecode_config_ini, ''),
-    ## systems stats
-    (_('RhodeCode Enterprise Server IP'), c.server_ip, ''),
-    (_('RhodeCode Enterprise Server ID'), c.server_id, ''),
-    (_('Platform'), c.platform, ''),
-    (_('Uptime'), c.uptime_age, ''),
-    (_('Storage location'), c.storage, ''),
-    (_('Storage disk space'), "%s/%s, %s%% used%s" % (h.format_byte_size_binary(c.disk['used']), h.format_byte_size_binary(c.disk['total']),(c.disk['percent']), ' %s' % c.disk['error'] if 'error' in c.disk else ''), ''),
-
-    (_('Search index storage'), c.index_storage, ''),
-    (_('Search index size'), "%s %s" % (h.format_byte_size_binary(c.disk_index['used']), ' %s' % c.disk_index['error'] if 'error' in c.disk_index else ''), ''),
-
-    (_('Gist storage'), c.gist_storage, ''),
-    (_('Gist storage size'), "%s (%s items)%s" % (h.format_byte_size_binary(c.disk_gist['used']),c.disk_gist['items'], ' %s' % c.disk_gist['error'] if 'error' in c.disk_gist else ''), ''),
-
-    (_('Archive cache'), h.literal('%s <br/><span >%s.</span>' % (c.archive_storage, _('Enable this by setting archive_cache_dir=/path/to/cache option in the .ini file'))), ''),
-    (_('Archive cache size'), "%s%s" % (h.format_byte_size_binary(c.disk_archive['used']), ' %s' % c.disk_archive['error'] if 'error' in c.disk_archive else ''), ''),
-
-    (_('System memory'), c.system_memory, ''),
-    (_('CPU'), '%s %%' %(c.cpu), ''),
-    (_('Load'), '1min: %s, 5min: %s, 15min: %s' %(c.load['1_min'],c.load['5_min'],c.load['15_min']), ''),
-
-    ## rhodecode stuff
-    (_('Python version'), c.py_version, ''),
-    (_('Python path'), c.py_path, ''),
-    (_('GIT version'), c.git_version, ''),
-    (_('HG version'), c.hg_version, ''),
-    (_('SVN version'), c.svn_version, ''),
-    (_('Database'), "%s @ version: %s" % (c.db_type, c.db_migrate_version), ''),
-    (_('Database version'), c.db_version, ''),
-
- ]
-%>
 
 <div id="update_notice" style="display: none; margin: -40px 0px 20px 0px">
     <div>${_('Checking for updates...')}</div>
@@ -46,15 +8,21 b''
     <div class="panel-heading">
         <h3 class="panel-title">${_('System Info')}</h3>
         % if c.allowed_to_snapshot:
-            <a href="${url('admin_settings_system', snapshot=1)}" class="panel-edit">${_('create snapshot')}</a>
+            <a href="${url('admin_settings_system', snapshot=1)}" class="panel-edit">${_('create summary snapshot')}</a>
         % endif
     </div>
     <div class="panel-body">
         <dl class="dl-horizontal settings">
-        %for dt, dd, tt in elems:
-          <dt>${dt}:</dt>
-          <dd title="${tt}">${dd}</dd>
-        %endfor
+        % for dt, dd, warn in c.data_items:
+          <dt>${dt}${':' if dt else '---'}</dt>
+          <dd>${dd}${'' if dt else '---'}
+              % if warn and warn['message']:
+                  <div class="alert-${warn['type']}">
+                    <strong>${warn['message']}</strong>
+                  </div>
+              % endif
+          </dd>
+        % endfor
         </dl>
     </div>
 </div>
@@ -70,12 +38,12 b''
               <col class='content'>
           </colgroup>
           <tbody>
-              %for key, value in c.py_modules:
+              % for key, value in c.py_modules['human_value']:
                   <tr>
                       <td>${key}</td>
                       <td>${value}</td>
                   </tr>
-              %endfor
+              % endfor
           </tbody>
         </table>
     </div>

rhodecode/templates/admin/settings/settings_system_snapshot.html

@@ -1,61 +1,26 b''
-<%
- elems = [
-    ## general
-    (_('RhodeCode Enterprise version'), c.rhodecode_version, ''),
-    (_('Upgrade info endpoint'), c.rhodecode_update_url, ''),
-    (_('Configuration INI file'), c.rhodecode_config_ini, ''),
-    ## systems stats
-    (_('RhodeCode Enterprise Server IP'), c.server_ip, ''),
-    (_('RhodeCode Enterprise Server ID'), c.server_id, ''),
-    (_('Platform'), c.platform, ''),
-    (_('Uptime'), c.uptime_age, ''),
-    (_('Storage location'), c.storage, ''),
-    (_('Storage disk space'), "%s/%s, %s%% used%s" % (h.format_byte_size_binary(c.disk['used']), h.format_byte_size_binary(c.disk['total']),(c.disk['percent']), ' %s' % c.disk['error'] if 'error' in c.disk else ''), ''),
-
-    (_('Search index storage'), c.index_storage, ''),
-    (_('Search index size'), "%s %s" % (h.format_byte_size_binary(c.disk_index['used']), ' %s' % c.disk_index['error'] if 'error' in c.disk_index else ''), ''),
-
-    (_('Gist storage'), c.gist_storage, ''),
-    (_('Gist storage size'), "%s (%s items)%s" % (h.format_byte_size_binary(c.disk_gist['used']),c.disk_gist['items'], ' %s' % c.disk_gist['error'] if 'error' in c.disk_gist else ''), ''),
-
-    (_('Archive cache'), c.archive_storage, ''),
-    (_('Archive cache size'), "%s%s" % (h.format_byte_size_binary(c.disk_archive['used']), ' %s' % c.disk_archive['error'] if 'error' in c.disk_archive else ''), ''),
-
-    (_('System memory'), c.system_memory, ''),
-    (_('CPU'), '%s %%' %(c.cpu), ''),
-    (_('Load'), '1min: %s, 5min: %s, 15min: %s' %(c.load['1_min'],c.load['5_min'],c.load['15_min']), ''),
-
-    ## rhodecode stuff
-    (_('Python version'), c.py_version, ''),
-    (_('Python path'), c.py_path, ''),
-    (_('GIT version'), c.git_version, ''),
-    (_('HG version'), c.hg_version, ''),
-    (_('SVN version'), c.svn_version, ''),
-    (_('Database'), "%s @ version: %s" % (c.db_type, c.db_migrate_version), ''),
-    (_('Database version'), c.db_version, ''),
-
- ]
-%>
 
 <pre>
 SYSTEM INFO
 -----------
 
-% for dt, dd, tt in elems:
-${dt}: ${dd}
+% for dt, dd, warn in c.data_items:
+  ${dt.lower().replace(' ', '_')}${': '+dd if dt else '---'}
+  % if warn and warn['message']:
+        ALERT_${warn['type'].upper()} ${warn['message']}
+  % endif
 % endfor
 
 PYTHON PACKAGES
 ---------------
 
-% for key, value in c.py_modules:
+% for key, value in c.py_modules['human_value']:
 ${key}: ${value}
 % endfor
 
 SYSTEM SETTINGS
 ---------------
 
-% for key, value in sorted(c.rhodecode_ini_safe.items()):
+% for key, value in sorted(c.rhodecode_config['human_value'].items()):
   % if isinstance(value, dict):
 
     % for key2, value2 in value.items():

rhodecode/templates/admin/settings/settings_vcs.html

@@ -50,5 +50,17 b''
         if ($('.locked_input').children().hasClass('error-message')) {
             unlockpath();
         }
-    })
+
+        /* On click handler for the `Generate Apache Config` button. It sends a
+        POST request to trigger the (re)generation of the mod_dav_svn config. */
+        $('#vcs_svn_generate_cfg').on('click', function(event) {
+            event.preventDefault();
+            var url = "${h.route_path('admin_settings_vcs_svn_generate_cfg')}";
+            var jqxhr = $.post(url, {'csrf_token': CSRF_TOKEN});
+            jqxhr.done(function(data) {
+                $.Topic('/notifications').publish(data);
+            });
+        });
+
+    });
 </script>

rhodecode/templates/admin/settings/settings_visual.html

@@ -69,6 +69,8 b''
                 <tr><td>[featured] </td><td><span class="metatag" tag="featured">featured</span></td></tr>
                 <tr><td>[stale] </td><td><span class="metatag" tag="stale">stale</span></td></tr>
                 <tr><td>[dead] </td><td><span class="metatag" tag="dead">dead</span></td></tr>
+                <tr><td>[personal] </td><td><span class="metatag" tag="personal">personal</span></td></tr>
+
                 <tr><td>[lang =&gt; lang] </td><td><span class="metatag" tag="lang" >lang</span></td></tr>
 
                 <tr><td>[license =&gt; License] </td><td><span class="metatag" tag="license"><a href="http://www.opensource.org/licenses/License" >License</a></span></td></tr>

rhodecode/templates/admin/user_groups/user_group_edit.html

@@ -35,7 +35,6 b''
           <li class="${'active' if c.active=='advanced' else ''}"><a href="${h.url('edit_user_group_advanced', user_group_id=c.user_group.users_group_id)}">${_('Advanced')}</a></li>
           <li class="${'active' if c.active=='global_perms' else ''}"><a href="${h.url('edit_user_group_global_perms', user_group_id=c.user_group.users_group_id)}">${_('Global permissions')}</a></li>
           <li class="${'active' if c.active=='perms_summary' else ''}"><a href="${h.url('edit_user_group_perms_summary', user_group_id=c.user_group.users_group_id)}">${_('Permissions summary')}</a></li>
-          <li class="${'active' if c.active=='members' else ''}"><a href="${h.url('edit_user_group_members', user_group_id=c.user_group.users_group_id)}">${_('Members')}</a></li>
         </ul>
     </div>
 

rhodecode/templates/admin/user_groups/user_group_edit_settings.html

@@ -54,40 +54,53 b''
                             ${h.checkbox('users_group_active',value=True)}
                         </div>
                      </div>
-                    <div class="field">
-                        <div class="label">
-                            <label for="users_group_active">${_('Search')}:</label>
-                               ${h.text('from_user_group',
-                                        placeholder="user/usergroup",
-                                        class_="medium")}
+
+                     <div class="field">
+                        <div class="label label-checkbox">
+                            <label for="users_group_active">${_('Add members')}:</label>
+                        </div>
+                        <div class="input">
+                            ${h.text('user_group_add_members', placeholder="user/usergroup", class_="medium")}
                         </div>
-                        <div class="select side-by-side-selector">
-                            <div class="left-group">
-                                <label class="text"><strong>${_('Chosen group members')}</strong></label>
-                                ${h.select('users_group_members',[x[0] for x in c.group_members],c.group_members,multiple=True,size=8,)}
-                               <div class="btn" id="remove_all_elements" >
-                                   ${_('Remove all elements')}
-                                   <i  class="icon-chevron-right"></i>
-                               </div>
-                            </div>
-                            <div class="middle-group">
-                                <i  id="add_element" class="icon-chevron-left"></i>
-                                <br />
-                                <i  id="remove_element" class="icon-chevron-right"></i>
-                            </div>
-                            <div class="right-group">
-                                 <label class="text" >${_('Available users')}
-                                 </label>
-                                 ${h.select('available_members',[],c.available_members,multiple=True,size=8,)}
-                                 <div  class="btn" id="add_all_elements" >
-                                     <i  class="icon-chevron-left"></i>${_('Add all elements')}
-                                 </div>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="buttons">
-                      ${h.submit('Save',_('Save'),class_="btn")}
-                    </div>
+                     </div>
+
+                    <input type="hidden" name="__start__" value="user_group_members:sequence"/>
+                    <table id="group_members_placeholder" class="rctable group_members">
+                        <tr>
+                          <th>${_('Username')}</th>
+                          <th>${_('Action')}</th>
+                        </tr>
+
+                        % if c.group_members_obj:
+                          % for user in c.group_members_obj:
+                            <tr>
+                              <td id="member_user_${user.user_id}" class="td-author">
+                                <div class="group_member">
+                                  ${base.gravatar(user.email, 16)}
+                                  <span class="username user">${h.link_to(h.person(user), h.url( 'edit_user',user_id=user.user_id))}</span>
+                                  <input type="hidden" name="__start__" value="member:mapping">
+                                  <input type="hidden" name="member_user_id" value="${user.user_id}">
+                                  <input type="hidden" name="type" value="existing" id="member_${user.user_id}">
+                                  <input type="hidden" name="__end__" value="member:mapping">
+                                </div>
+                              </td>
+                              <td class="">
+                                <div class="usergroup_member_remove action_button" onclick="removeUserGroupMember(${user.user_id}, true)" style="visibility: visible;">
+                                    <i class="icon-remove-sign"></i>
+                                </div>
+                              </td>
+                            </tr>
+                          % endfor
+
+                        % else:
+                          <tr><td colspan="2">${_('No members yet')}</td></tr>
+                        % endif
+                     </table>
+                    <input type="hidden" name="__end__" value="user_group_members:sequence"/>
+
+                     <div class="buttons">
+                       ${h.submit('Save',_('Save'),class_="btn")}
+                     </div>
                 </div>
         </div>
     ${h.end_form()}
@@ -95,15 +108,18 b''
 </div>
 <script>
     $(document).ready(function(){
-        MultiSelectWidget('users_group_members','available_members','edit_users_group');
-
         $("#group_parent_id").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'dropdownAutoWidth': true
         });
 
-        $('#from_user_group').autocomplete({
+        removeUserGroupMember = function(userId){
+            $('#member_'+userId).val('remove');
+            $('#member_user_'+userId).addClass('to-delete');
+        };
+
+        $('#user_group_add_members').autocomplete({
             serviceUrl: pyroutes.url('user_autocomplete_data'),
             minChars:2,
             maxHeight:400,
@@ -115,9 +131,37 b''
             lookupFilter: autocompleteFilterResult,
             onSelect: function(element, suggestion){
 
-                function preSelectUserIds(uids) {
-                    $('#available_members').val(uids);
-                    $('#users_group_members').val(uids);
+                function addMember(user, fromUserGroup) {
+                    var gravatar = user.icon_link;
+                    var username = user.value_display;
+                    var userLink = pyroutes.url('edit_user', {"user_id": user.id});
+                    var uid = user.id;
+
+                    if (fromUserGroup) {
+                        username = username +" "+ _gettext('(from usergroup {0})'.format(fromUserGroup))
+                    }
+
+                    var elem = $(
+                        ('<tr>'+
+                          '<td id="member_user_{6}" class="td-author td-author-new-entry">'+
+                            '<div class="group_member">'+
+                              '<img class="gravatar" src="{0}" height="16" width="16">'+
+                              '<span class="username user"><a href="{1}">{2}</a></span>'+
+                              '<input type="hidden" name="__start__" value="member:mapping">'+
+                              '<input type="hidden" name="member_user_id" value="{3}">'+
+                              '<input type="hidden" name="type" value="new" id="member_{4}">'+
+                              '<input type="hidden" name="__end__" value="member:mapping">'+
+                            '</div>'+
+                          '</td>'+
+                          '<td class="td-author-new-entry">'+
+                            '<div class="usergroup_member_remove action_button" onclick="removeUserGroupMember({5}, true)" style="visibility: visible;">'+
+                                '<i class="icon-remove-sign"></i>'+
+                            '</div>'+
+                          '</td>'+
+                        '</tr>').format(gravatar, userLink, username,
+                                uid, uid, uid, uid)
+                    );
+                    $('#group_members_placeholder').append(elem)
                 }
 
                 if (suggestion.value_type == 'user_group') {
@@ -125,20 +169,18 b''
                         pyroutes.url('edit_user_group_members',
                                     {'user_group_id': suggestion.id}),
                         function(data) {
-                            var uids = [];
                             $.each(data.members, function(idx, user) {
-                                var userid = user[0],
-                                    username = user[1];
-                                uids.push(userid.toString());
+                                addMember(user, suggestion.value)
                             });
-                            preSelectUserIds(uids)
                         }
                     );
                 } else if (suggestion.value_type == 'user') {
-                    preSelectUserIds([suggestion.id.toString()]);
+                    addMember(suggestion, null);
                 }
             }
         });
+
+
         UsersAutoComplete('user', '${c.rhodecode_user.user_id}');
     })
 </script>

rhodecode/templates/admin/users/user_add.html

@@ -113,11 +113,14 b''
 
             <div class="field">
                 <div class="label label-checkbox">
-                    <label for="create_repo_group">${_('Add repository group')}:</label>
+                    <label for="create_repo_group">${_('Add personal repository group')}:</label>
                 </div>
                 <div class="checkboxes">
-                    ${h.checkbox('create_repo_group',value=True)}
-                    <span class="help-block">${_('Add repository group with the same name as username. \nUser will be automatically set as this group owner.')}</span>
+                    ${h.checkbox('create_repo_group',value=True, checked=c.default_create_repo_group)}
+                    <span class="help-block">
+                        ${_('New group will be created at: `/%(path)s`') % {'path': c.personal_repo_group_name}}<br/>
+                        ${_('User will be automatically set as this group owner.')}
+                    </span>
                 </div>
              </div>
 

rhodecode/templates/admin/users/user_edit_advanced.html

@@ -61,7 +61,11 b''
         %if c.personal_repo_group:
             <div class="panel-body-title-text">${_('Users personal repository group')} : ${h.link_to(c.personal_repo_group.group_name, url('repo_group_home', group_name=c.personal_repo_group.group_name))}</div>
         %else:
-            <div class="panel-body-title-text">${_('This user currently does not have a personal repository group')}</div>
+            <div class="panel-body-title-text">
+                ${_('This user currently does not have a personal repository group')}
+                <br/>
+                ${_('New group will be created at: `/%(path)s`') % {'path': c.personal_repo_group_name}}
+            </div>
         %endif
             <button class="btn btn-default" type="submit" ${'disabled="disabled"' if c.personal_repo_group else ''}>
                 <i class="icon-folder-close"></i>

rhodecode/templates/admin/users/users.html

@@ -50,16 +50,18 b''
     $.fn.dataTable.ext.search.push(
         function( settings, data, dataIndex ) {
             var query = $('#q_filter').val();
-            var username = data[1];
-            var email = data[2];
-            var first_name = data[3];
-            var last_name = data[4];
+
+            var username = data[0];
+            var email = data[1];
+            var first_name = data[2];
+            var last_name = data[3];
 
             var query_str = username + " " +
                             email + " " +
                             first_name + " " +
                             last_name;
-            if((query_str).indexOf(query) !== -1){
+
+            if ((query_str).indexOf(query) !== -1) {
                 return true;
             }
             return false;

rhodecode/templates/base/base.html

@@ -23,7 +23,6 b''
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
-      ${self.flash_msg()}
       <div class="main">
           ${next.main()}
       </div>
@@ -62,10 +61,6 b''
 <%def name="menu_bar_subnav()">
 </%def>
 
-<%def name="flash_msg()">
-    <%include file="/base/flash_msg.html"/>
-</%def>
-
 <%def name="breadcrumbs(class_='breadcrumbs')">
     <div class="${class_}">
     ${self.breadcrumbs_links()}
@@ -100,12 +95,12 b''
           ${dd}
       %endif
       %if show_items:
-          <span class="btn-collapse" data-toggle="item-${h.md5(dt)[:6]}-details">${_('Show More')} </span>
+          <span class="btn-collapse" data-toggle="item-${h.md5_safe(dt)[:6]}-details">${_('Show More')} </span>
       %endif
       </dd>
 
       %if show_items:
-          <div class="collapsable-content" data-toggle="item-${h.md5(dt)[:6]}-details" style="display: none">
+          <div class="collapsable-content" data-toggle="item-${h.md5_safe(dt)[:6]}-details" style="display: none">
           %for item in show_items:
               <dt></dt>
               <dd>${item}</dd>
@@ -313,7 +308,9 b''
                     <div class="field">
                         <div class="label">
                             <label for="password">${_('Password')}:</label>
-                            <span class="forgot_password">${h.link_to(_('(Forgot password?)'),h.route_path('reset_password'))}</span>
+                            %if h.HasPermissionAny('hg.password_reset.enabled')():
+                              <span class="forgot_password">${h.link_to(_('(Forgot password?)'),h.route_path('reset_password'), class_='pwd_reset')}</span>
+                            %endif
                         </div>
                         <div class="input">
                             ${h.password('password',class_='focus',tabindex=2)}
@@ -341,6 +338,9 b''
             <div class="">
             <ol class="links">
               <li>${h.link_to(_(u'My account'),h.url('my_account'))}</li>
+              % if c.rhodecode_user.personal_repo_group:
+                <li>${h.link_to(_(u'My personal group'), h.url('repo_group_home', group_name=c.rhodecode_user.personal_repo_group.group_name))}</li>
+              % endif
               <li class="logout">
               ${h.secure_form(h.route_path('logout'))}
                   ${h.submit('log_out', _(u'Sign Out'),class_="btn btn-primary")}

rhodecode/templates/base/root.html

@@ -12,11 +12,15 b" if getattr(c, 'rhodecode_user', None) an"
     c.template_context['rhodecode_user']['username'] = c.rhodecode_user.username
     c.template_context['rhodecode_user']['email'] = c.rhodecode_user.email
     c.template_context['rhodecode_user']['notification_status'] = c.rhodecode_user.get_instance().user_data.get('notification_status', True)
+    c.template_context['rhodecode_user']['first_name'] = c.rhodecode_user.name
+    c.template_context['rhodecode_user']['last_name'] = c.rhodecode_user.lastname
 
 c.template_context['visual']['default_renderer'] = h.get_visual_attr(c, 'default_renderer')
 %>
 <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
+        <script src="${h.asset('js/vendors/webcomponentsjs/webcomponents-lite.min.js', ver=c.rhodecode_version_hash)}"></script>
+        <link rel="import" href="${h.asset('js/rhodecode-components.html', ver=c.rhodecode_version_hash)}">
         <title>${self.title()}</title>
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
         <%def name="robots()">
@@ -64,10 +68,6 b" c.template_context['visual']['default_re"
                             && 'content' in document.createElement('template')
                     );
                     if (!webComponentsSupported) {
-                        var e = document.createElement('script');
-                        e.async = true;
-                        e.src = '${h.asset('js/vendors/webcomponentsjs/webcomponents-lite.min.js', ver=c.rhodecode_version_hash)}';
-                        document.head.appendChild(e);
                     } else {
                         onload();
                     }
@@ -108,22 +108,22 b" c.template_context['visual']['default_re"
                   ip: '${c.rhodecode_user.ip_addr}',
                   username: '${c.rhodecode_user.username}'
               % endif
+              },
+              tags: {
+                  rhodecode_version: '${c.rhodecode_version}',
+                  rhodecode_edition: '${c.rhodecode_edition}'
               }
             };
+
             </script>
             <%include file="/base/plugins_base.html"/>
             <!--[if lt IE 9]>
             <script language="javascript" type="text/javascript" src="${h.asset('js/excanvas.min.js')}"></script>
             <![endif]-->
             <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode/routes.js', ver=c.rhodecode_version_hash)}"></script>
-            <script language="javascript" type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script>
-            <script>
-                var e = document.createElement('script');
-                e.src = '${h.asset('js/rhodecode-components.js', ver=c.rhodecode_version_hash)}';
-                document.head.appendChild(e);
-            </script>
-            <link rel="import" href="${h.asset('js/rhodecode-components.html', ver=c.rhodecode_version_hash)}">
+            <script> var alertMessagePayloads = ${h.flash.json_alerts()|n}; </script>
             ## avoide escaping the %N
+            <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode-components.js', ver=c.rhodecode_version_hash)}"></script>
             <script>CodeMirror.modeURL = "${h.asset('') + 'js/mode/%N/%N.js?ver='+c.rhodecode_version_hash}";</script>
 
 
@@ -131,6 +131,13 b" c.template_context['visual']['default_re"
             ${self.js_extra()}
 
             <script type="text/javascript">
+            Rhodecode = (function() {
+                function _Rhodecode() {
+                  this.comments = new CommentsController();
+                }
+                return new _Rhodecode();
+            })();
+
             $(document).ready(function(){
               show_more_event();
               timeagoActivate();
@@ -145,11 +152,6 b" c.template_context['visual']['default_re"
 
         <%def name="head_extra()"></%def>
         ${self.head_extra()}
-        <script>
-            window.addEventListener("load", function(event) {
-                $.Topic('/plugins/__REGISTER__').prepareOrPublish({});
-            });
-        </script>
         ## extra stuff
         %if c.pre_code:
             ${c.pre_code|n}

rhodecode/templates/base/vcs_settings.html

@@ -126,7 +126,7 b''
 
                     <div class="checkbox">
                         ${h.checkbox('rhodecode_hg_use_rebase_for_merging' + suffix, 'True', **kwargs)}
-                        <label for="rhodecode_hg_use_rebase_for_merging{suffix}">${_('Use rebase as merge strategy')}</label>
+                        <label for="rhodecode_hg_use_rebase_for_merging${suffix}">${_('Use rebase as merge strategy')}</label>
                     </div>
                     <div class="label">
                         <span class="help-block">${_('Use rebase instead of creating a merge commit when merging via web interface.')}</span>
@@ -147,10 +147,13 b''
                 <div class="field">
                     <div class="checkbox">
                         ${h.checkbox('vcs_svn_proxy_http_requests_enabled' + suffix, 'True', **kwargs)}
-                        <label for="vcs_svn_proxy_http_requests_enabled{suffix}">${_('Proxy subversion HTTP requests')}</label>
+                        <label for="vcs_svn_proxy_http_requests_enabled${suffix}">${_('Proxy subversion HTTP requests')}</label>
                     </div>
                     <div class="label">
-                        <span class="help-block">${_('Subversion HTTP Support. Enables communication with SVN over HTTP protocol.')}</span>
+                        <span class="help-block">
+                            ${_('Subversion HTTP Support. Enables communication with SVN over HTTP protocol.')}
+                            <a href="${h.url('enterprise_svn_setup')}" target="_blank">${_('SVN Protocol setup Documentation')}</a>.
+                        </span>
                     </div>
                 </div>
                 <div class="field">
@@ -161,6 +164,11 b''
                         ${h.text('vcs_svn_proxy_http_server_url',size=59)}
                     </div>
                 </div>
+                % if c.svn_proxy_generate_config:
+                    <div class="buttons">
+                        <button class="btn btn-primary" id="vcs_svn_generate_cfg">${_('Generate Apache Config')}</button>
+                    </div>
+                % endif
             </div>
         </div>
     % endif

rhodecode/templates/changelog/changelog_file_history.html

@@ -17,7 +17,7 b''
 
                     %if cs.merge:
                         <span class="mergetag">
-                         ${_('merge')}
+                         <i class="icon-merge"></i>${_('merge')}
                         </span>
                     %endif
                     <div class="message_history" title="${cs.message}">

rhodecode/templates/changeset/changeset.html

@@ -42,12 +42,12 b''
           <span id="parent_link">
             <a href="#" title="${_('Parent Commit')}">${_('Parent')}</a>
           </span>
-           | 
+           |
           <span id="child_link">
             <a href="#" title="${_('Child Commit')}">${_('Child')}</a>
           </span>
       </div>
-  
+
       <div class="fieldset">
         <div class="left-label">
           ${_('Description')}:
@@ -59,7 +59,7 b''
           </div>
         </div>
       </div>
-  
+
       %if c.statuses:
       <div class="fieldset">
         <div class="left-label">
@@ -73,20 +73,20 b''
         </div>
       </div>
       %endif
-  
+
       <div class="fieldset">
         <div class="left-label">
           ${_('References')}:
         </div>
         <div class="right-content">
           <div class="tags">
-  
+
             %if c.commit.merge:
               <span class="mergetag tag">
-               ${_('merge')}
+               <i class="icon-merge"></i>${_('merge')}
               </span>
             %endif
-  
+
             %if h.is_hg(c.rhodecode_repo):
               %for book in c.commit.bookmarks:
               <span class="booktag tag" title="${_('Bookmark %s') % book}">
@@ -94,13 +94,13 b''
               </span>
               %endfor
             %endif
-  
+
             %for tag in c.commit.tags:
              <span class="tagtag tag"  title="${_('Tag %s') % tag}">
               <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"><i class="icon-tag"></i>${tag}</a>
              </span>
             %endfor
-  
+
             %if c.commit.branch:
               <span class="branchtag tag" title="${_('Branch %s') % c.commit.branch}">
                 <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"><i class="icon-code-fork"></i>${h.shorter(c.commit.branch)}</a>
@@ -119,22 +119,22 b''
               <a href="${h.url('changeset_raw_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"  class="tooltip" title="${h.tooltip(_('Raw diff'))}">
                 ${_('Raw Diff')}
               </a>
-               | 
+               |
               <a href="${h.url('changeset_patch_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"  class="tooltip" title="${h.tooltip(_('Patch diff'))}">
                 ${_('Patch Diff')}
               </a>
-               | 
+               |
               <a href="${h.url('changeset_download_home',repo_name=c.repo_name,revision=c.commit.raw_id,diff='download')}" class="tooltip" title="${h.tooltip(_('Download diff'))}">
                 ${_('Download Diff')}
               </a>
-               | 
+               |
               ${c.ignorews_url(request.GET)}
-               | 
+               |
               ${c.context_url(request.GET)}
             </div>
         </div>
       </div>
-  
+
       <div class="fieldset">
         <div class="left-label">
           ${_('Comments')}:
@@ -147,17 +147,16 b''
                     ${ungettext("%d Commit comment", "%d Commit comments", len(c.comments)) % len(c.comments)}
                 %endif
                 %if c.inline_cnt:
-                    ## this is replaced with a proper link to first comment via JS linkifyComments() func
-                    <a href="#inline-comments" id="inline-comments-counter">${ungettext("%d Inline Comment", "%d Inline Comments", c.inline_cnt) % c.inline_cnt}</a>
+                    <a href="#" onclick="return Rhodecode.comments.nextComment();" id="inline-comments-counter">${ungettext("%d Inline Comment", "%d Inline Comments", c.inline_cnt) % c.inline_cnt}</a>
                 %else:
                     ${ungettext("%d Inline Comment", "%d Inline Comments", c.inline_cnt) % c.inline_cnt}
                 %endif
             </div>
         </div>
       </div>
-  
+
     </div> <!-- end summary-detail -->
-              
+
     <div id="commit-stats" class="sidebar-right">
       <div class="summary-detail-header">
         <h4 class="item">
@@ -170,102 +169,24 b''
         </div>
     </div><!-- end sidebar -->
   </div> <!-- end summary -->
-  <div class="cs_files_title">
-    <span class="cs_files_expand">
-        <span id="files_link"><a href="#" title="${_('Browse files at current commit')}">${_('Browse files')}</a></span> |
-
-        <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-    </span>
-    <h2>
-        ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-    </h2>
+  <div class="cs_files">
+    <%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
+    ${cbdiffs.render_diffset_menu()}
+    ${cbdiffs.render_diffset(
+      c.changes[c.commit.raw_id], commit=c.commit, use_comments=True)}
   </div>
-</div> 
-
-<div class="cs_files">
-
-  %if not c.files:
-     <p class="empty_data">${_('No files')}</p>
-  %endif
-
-  <table class="compare_view_files commit_diff">
-      %for FID, (cs1, cs2, change, path, diff, stats, file) in c.changes[c.commit.raw_id].iteritems():
-        <tr class="cs_${change} collapse_file" fid="${FID}">
-          <td class="cs_icon_td">
-              <span class="collapse_file_icon" fid="${FID}"></span>
-          </td>
-          <td class="cs_icon_td">
-              <div class="flag_status not_reviewed hidden"></div>
-          </td>
-          <td class="cs_${change}" id="a_${FID}">
-            <div class="node">
-                <a href="#a_${FID}">
-                    <i class="icon-file-${change.lower()}"></i>
-                    ${h.safe_unicode(path)}
-                </a>
-            </div>
-          </td>
-          <td>
-            <div class="changes pull-right">${h.fancy_file_stats(stats)}</div>
-            <div class="comment-bubble pull-right" data-path="${path}">
-              <i class="icon-comment"></i>
-            </div>
-          </td>
-        </tr>
-        <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-          <td></td>
-          <td></td>
-          <td class="cs_${change}">
-            ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), cs1, cs2, change, file)}
-          </td>
-          <td class="td-actions rc-form">
-            ${c.ignorews_url(request.GET, h.FID(cs2,path))} |
-            ${c.context_url(request.GET, h.FID(cs2,path))} |
-            <div data-comment-id="${h.FID(cs2,path)}" class="btn-link show-inline-comments comments-visible">
-              <span class="comments-show">${_('Show comments')}</span>
-              <span class="comments-hide">${_('Hide comments')}</span>
-            </div>
-          </td>
-        </tr>
-        <tr id="tr_${FID}">
-          <td></td>
-          <td></td>
-          <td class="injected_diff" colspan="2">
-            <div class="diff-container" id="${'diff-container-%s' % (id(change))}">
-              <div id="${FID}" class="diffblock margined comm">
-                <div class="code-body">
-                    <div class="full_f_path" path="${h.safe_unicode(path)}"></div>
-                    ${diff|n}
-                    % if file and file["is_limited_diff"]:
-                      % if file["exceeds_limit"]:
-                        ${diff_block.file_message()}
-                      % else:
-                        <h5>${_('Diff was truncated. File content available only in full diff.')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a></h5>
-                      % endif
-                    % endif
-                </div>
-              </div>
-            </div>
-          </td>
-        </tr>
-      %endfor
-  </table>
-</div>
-
-    % if c.limited_diff:
-          ${diff_block.changeset_message()}
-    % endif
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
 
-    ## render comments and inlines
+    ## ## render comments and inlines
     ${comment.generate_comments()}
 
     ## main comment form and it status
     ${comment.comments(h.url('changeset_comment', repo_name=c.repo_name, revision=c.commit.raw_id),
                        h.commit_status(c.rhodecode_db_repo, c.commit.raw_id))}
+</div>
 
     ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
     <script type="text/javascript">
@@ -388,7 +309,6 b''
 
           // inject comments into their proper positions
           var file_comments = $('.inline-comment-placeholder');
-          renderInlineComments(file_comments, true);
       })
     </script>
 

rhodecode/templates/changeset/changeset_file_comment.html

@@ -6,7 +6,14 b''
 <%namespace name="base" file="/base/base.html"/>
 
 <%def name="comment_block(comment, inline=False)">
-  <div class="comment ${'comment-inline' if inline else ''}" id="comment-${comment.comment_id}" line="${comment.line_no}" data-comment-id="${comment.comment_id}">
+  <div
+    class="comment
+    ${'comment-inline' if inline else ''}
+    ${'comment-outdated' if comment.outdated else 'comment-current'}"
+    "
+    id="comment-${comment.comment_id}"
+    line="${comment.line_no}"
+    data-comment-id="${comment.comment_id}">
       <div class="meta">
           <div class="author">
               ${base.gravatar_with_user(comment.author.email, 16)}
@@ -46,24 +53,15 b''
             ## only super-admin, repo admin OR comment owner can delete
             %if not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed()):
                %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id:
-                  <div onClick="deleteComment(${comment.comment_id})" class="delete-comment"> ${_('Delete')}</div>
-                  %if inline:
-                    <div class="comment-links-divider"> | </div>
+                  ## TODO: dan: add edit comment here
+                  <a onclick="return Rhodecode.comments.deleteComment(this);" class="delete-comment"> ${_('Delete')}</a> |
+                  %if not comment.outdated:
+                  <a onclick="return Rhodecode.comments.prevComment(this);" class="prev-comment"> ${_('Prev')}</a> |
+                  <a onclick="return Rhodecode.comments.nextComment(this);" class="next-comment"> ${_('Next')}</a>
                   %endif
                %endif
             %endif
 
-            %if inline:
-
-                <div id="prev_c_${comment.comment_id}" class="comment-previous-link" title="${_('Previous comment')}">
-                  <a class="arrow_comment_link disabled"><i class="icon-left"></i></a>
-                </div>
-
-                <div id="next_c_${comment.comment_id}" class="comment-next-link" title="${_('Next comment')}">
-                  <a class="arrow_comment_link disabled"><i class="icon-right"></i></a>
-                </div>
-            %endif
-
           </div>
       </div>
       <div class="text">
@@ -165,31 +163,8 b''
 </%def>
 
 
-## generates inlines taken from c.comments var
-<%def name="inlines(is_pull_request=False)">
-    %if is_pull_request:
-    <h2 id="comments">${ungettext("%d Pull Request Comment", "%d Pull Request Comments", len(c.comments)) % len(c.comments)}</h2>
-    %else:
-    <h2 id="comments">${ungettext("%d Commit Comment", "%d Commit Comments", len(c.comments)) % len(c.comments)}</h2>
-    %endif
-    %for path, lines_comments in c.inline_comments:
-        % for line, comments in lines_comments.iteritems():
-            <div style="display: none;" class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">
-            ## for each comment in particular line
-            %for comment in comments:
-                ${comment_block(comment, inline=True)}
-            %endfor
-            </div>
-        %endfor
-    %endfor
-
-</%def>
-
-## generate inline comments and the main ones
+## generate main comments
 <%def name="generate_comments(include_pull_request=False, is_pull_request=False)">
-    ## generate inlines for this changeset
-     ${inlines(is_pull_request)}
-
     %for comment in c.comments:
         <div id="comment-tr-${comment.comment_id}">
           ## only render comments that are not from pull request, or from

rhodecode/templates/changeset/changeset_range.html

@@ -49,78 +49,23 b''
         ${self.breadcrumbs_links()}
       </h2>
     </div>
-
-    <div id="changeset_compare_view_content">
-      ##CS
-      <%include file="../compare/compare_commits.html"/>
-      ## FILES
-      <div class="cs_files_title">
-        <span class="cs_files_expand">
-            <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-        </span>
-        <h2>
-            ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-        </h2>
-      </div>
-    </div>
   </div>
-
-  <div class="cs_files">
-    <table class="compare_view_files">
+  <div id="changeset_compare_view_content">
+    ##CS
+    <%include file="../compare/compare_commits.html"/>
+    <div class="cs_files">
+      <%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
       <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
       <%namespace name="diff_block" file="/changeset/diff_block.html"/>
-      %for cs in c.commit_ranges:
-        <tr class="rctable">
-          <td colspan="4">
-              <a class="tooltip revision" title="${h.tooltip(cs.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">${'r%s:%s' % (cs.revision,h.short_id(cs.raw_id))}</a> |
-              ${h.age_component(cs.date)}
-          </td>
-        </tr>
-          %for FID, (cs1, cs2, change, path, diff, stats, file) in c.changes[cs.raw_id].iteritems():
-            <tr class="cs_${change} collapse_file" fid="${FID}">
-              <td class="cs_icon_td">
-                  <span class="collapse_file_icon" fid="${FID}"></span>
-              </td>
-              <td class="cs_icon_td">
-                  <div class="flag_status not_reviewed hidden"></div>
-              </td>
-              <td class="cs_${change}" id="a_${FID}">
-                <div class="node">
-                    <a href="#a_${FID}">
-                        <i class="icon-file-${change.lower()}"></i>
-                        ${h.safe_unicode(path)}
-                    </a>
-                </div>
-              </td>
-              <td>
-                <div class="changes">${h.fancy_file_stats(stats)}</div>
-              </td>
-            </tr>
-            <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-              <td></td>
-              <td></td>
-              <td class="cs_${change}">
-                ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), cs1, cs2, change, file)}
-              </td>
-              <td class="td-actions rc-form"></td>
-            </tr>
-            <tr id="tr_${FID}">
-              <td></td>
-              <td></td>
-              <td class="injected_diff" colspan="2">
-                <div id="diff-container-${FID}" class="diff-container">
-                  <div id="${FID}" class="diffblock margined comm">
-                    <div class="code-body">
-                      ${diff|n}
-                    </div>
-                  </div>
-                </div>
-              </td>
-            </tr>
-          %endfor
-      %endfor
-    </table>
+      ${cbdiffs.render_diffset_menu()}
+      %for commit in c.commit_ranges:
+        ${cbdiffs.render_diffset(
+            diffset=c.changes[commit.raw_id],
+            collapse_when_files_over=5,
+            commit=commit,
+         )}
+        %endfor
+      </table>
+    </div>
   </div>
-## end summary detail
-
-</%def>
  No newline at end of file
+</%def>

rhodecode/templates/compare/compare_commits.html

@@ -15,6 +15,7 b''
     </p>
     %endif
 
+    <input type="hidden" name="__start__" value="revisions:sequence">
     <table class="rctable compare_view_commits">
         <tr>
             <th>${_('Time')}</th>
@@ -66,6 +67,7 b''
         </tr>
     %endfor
     </table>
+    <input type="hidden" name="__end__" value="revisions:sequence">
   %endif
 </div>
 

rhodecode/templates/compare/compare_diff.html

@@ -1,5 +1,6 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
+<%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
 
 <%def name="title()">
     %if c.compare_home:
@@ -53,7 +54,7 b''
                                     <a id="btn-swap" class="btn btn-primary" href="${c.swap_url}"><i class="icon-refresh"></i> ${_('Swap')}</a>
                                 %endif
                                 <div id="compare_revs" class="btn btn-primary"><i class ="icon-loop"></i> ${_('Compare Commits')}</div>
-                                %if c.files:
+                                %if c.diffset and c.diffset.files:
                                     <div id="compare_changeset_status_toggle" class="btn btn-primary">${_('Comment')}</div>
                                 %endif
                             </div>
@@ -248,72 +249,8 b''
                 <div id="changeset_compare_view_content">
                     ##CS
                     <%include file="compare_commits.html"/>
-
-                    ## FILES
-                  <div class="cs_files_title">
-                    <span class="cs_files_expand">
-                        <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-                    </span>
-                    <h2>
-                        ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-                    </h2>
-                  </div>
-                    <div class="cs_files">
-                      %if not c.files:
-                         <p class="empty_data">${_('No files')}</p>
-                      %endif
-                  <table class="compare_view_files">
-                  <%namespace name="diff_block" file="/changeset/diff_block.html"/>
-                    %for FID, change, path, stats, file in c.files:
-                    <tr class="cs_${change} collapse_file" fid="${FID}">
-                        <td class="cs_icon_td">
-                            <span class="collapse_file_icon" fid="${FID}"></span>
-                        </td>
-                        <td class="cs_icon_td">
-                            <div class="flag_status not_reviewed hidden"></div>
-                        </td>
-                        <td class="cs_${change}" id="a_${FID}">
-                            <div class="node">
-                                <a href="#a_${FID}">
-                                    <i class="icon-file-${change.lower()}"></i>
-                                    ${h.safe_unicode(path)}
-                                </a>
-                            </div>
-                        </td>
-                        <td>
-                            <div class="changes pull-right">${h.fancy_file_stats(stats)}</div>
-                            <div class="comment-bubble pull-right" data-path="${path}">
-                              <i class="icon-comment"></i>
-                            </div>
-                        </td>
-                    </tr>
-                    <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-                        <td></td>
-                        <td></td>
-                        <td class="cs_${change}">
-                            %if c.target_repo.repo_name == c.repo_name:
-                                ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), c.source_ref, c.target_ref, change, file)}
-                            %else:
-                                ## this is slightly different case later, since the target repo can have this
-                                ## file in target state than the source repo
-                                ${diff_block.diff_menu(c.target_repo.repo_name, h.safe_unicode(path), c.source_ref, c.target_ref, change, file)}
-                            %endif
-                        </td>
-                        <td class="td-actions rc-form">
-                        </td>
-                    </tr>
-                    <tr id="tr_${FID}">
-                      <td></td>
-                      <td></td>
-                      <td class="injected_diff" colspan="2">
-                          ${diff_block.diff_block_simple([c.changes[FID]])}
-                      </td>
-                    </tr>
-                  %endfor
-                  </table>
-                    % if c.limited_diff:
-                        ${diff_block.changeset_message()}
-                    % endif
+                    ${cbdiffs.render_diffset_menu()}
+                    ${cbdiffs.render_diffset(c.diffset)}
                  </div>
             %endif
         </div>

rhodecode/templates/data_table/_dt_elements.html

@@ -72,6 +72,10 b''
   </div>
 </%def>
 
+<%def name="repo_desc(description)">
+    <div class="truncate-wrap">${description}</div>
+</%def>
+
 <%def name="last_change(last_change)">
     ${h.age_component(last_change)}
 </%def>
@@ -167,6 +171,10 b''
   </div>
 </%def>
 
+<%def name="repo_group_desc(description)">
+    <div class="truncate-wrap">${description}</div>
+</%def>
+
 <%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">
  <div class="grid_edit">
     <a href="${h.url('edit_repo_group',group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
@@ -271,6 +279,12 b''
 
 
 ## PULL REQUESTS GRID RENDERERS
+
+<%def name="pullrequest_target_repo(repo_name)">
+    <div class="truncate">
+      ${h.link_to(repo_name,h.url('summary_home',repo_name=repo_name))}
+    </div>
+</%def>
 <%def name="pullrequest_status(status)">
     <div class="${'flag_status %s' % status} pull-left"></div>
 </%def>
@@ -284,9 +298,13 b''
     <i class="icon-comment icon-comment-colored"></i> ${comments_nr}
 </%def>
 
-<%def name="pullrequest_name(pull_request_id, target_repo_name)">
+<%def name="pullrequest_name(pull_request_id, target_repo_name, short=False)">
     <a href="${h.url('pullrequest_show',repo_name=target_repo_name,pull_request_id=pull_request_id)}">
-      ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
+      % if short:
+        #${pull_request_id}
+      % else:
+        ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
+      % endif
     </a>
 </%def>
 

rhodecode/templates/debug_style/form-elements.html

@@ -545,12 +545,6 b''
                       </div>
                   </div>
 
-                <script>
-                    $(document).ready(function(){
-                        MultiSelectWidget('users_group_members','available_members','edit_users_group');
-                    })
-                </script>
-
               </div>
 
               <div class='field'>
@@ -595,12 +589,6 b''
                       </div>
                   </div>
 
-                <script>
-                    $(document).ready(function(){
-                        MultiSelectWidget('users_group_members2','available_members','edit_users_group');
-                    })
-                </script>
-
               </div>
 
               <div class='field'>

rhodecode/templates/debug_style/icons.html

@@ -53,40 +53,46 b''
 
             <table id="icons-list">
                   <tr class="row">
-                    <td title="Code: 0xe800" class="the-icons span3"><i class="icon-plus"></i> <span class="i-name">icon-plus</span><span class="i-code">0xe800</span></td>
-                    <td title="Code: 0xe801" class="the-icons span3"><i class="icon-minus"></i> <span class="i-name">icon-minus</span><span class="i-code">0xe801</span></td>
-                    <td title="Code: 0xe802" class="the-icons span3"><i class="icon-remove"></i> <span class="i-name">icon-remove</span><span class="i-code">0xe802</span></td>
-                    <td title="Code: 0xe803" class="the-icons span3"><i class="icon-bookmark"></i> <span class="i-name">icon-bookmark</span><span class="i-code">0xe803</span></td>
-                  </tr>
-                  <tr class="row">
-                    <td title="Code: 0xe804" class="the-icons span3"><i class="icon-branch"></i> <span class="i-name">icon-branch</span><span class="i-code">0xe804</span></td>
-                    <td title="Code: 0xe805" class="the-icons span3"><i class="icon-tag"></i> <span class="i-name">icon-tag</span><span class="i-code">0xe805</span></td>
-                    <td title="Code: 0xe806" class="the-icons span3"><i class="icon-lock"></i> <span class="i-name">icon-lock</span><span class="i-code">0xe806</span></td>
-                    <td title="Code: 0xe807" class="the-icons span3"><i class="icon-unlock"></i> <span class="i-name">icon-unlock</span><span class="i-code">0xe807</span></td>
+                    <td title="Code: 0xe813" class="the-icons span3"><i class="icon-plus"></i>              <span class="i-name">icon-plus</span>           <span class="i-code">0xe813</span></td>
+                    <td title="Code: 0xe814" class="the-icons span3"><i class="icon-minus"></i>             <span class="i-name">icon-minus</span>          <span class="i-code">0xe814</span></td>
+                    <td title="Code: 0xe815" class="the-icons span3"><i class="icon-remove"></i>            <span class="i-name">icon-remove</span>         <span class="i-code">0xe815</span></td>
+                    <td title="Code: 0xe811" class="the-icons span3"><i class="icon-fork"></i>              <span class="i-name">icon-fork</span>           <span class="i-code">0xe811</span></td>
+                    <td title="Code: 0xe803" class="the-icons span3"><i class="icon-bookmark"></i>          <span class="i-name">icon-bookmark</span>       <span class="i-code">0xe803</span></td>
+                  </tr>     
+                  <tr class="row"> 
+                    <td title="Code: 0xe804" class="the-icons span3"><i class="icon-branch"></i>            <span class="i-name">icon-branch</span>         <span class="i-code">0xe804</span></td>
+                    <td title="Code: 0xe833" class="the-icons span3"><i class="icon-merge"></i>             <span class="i-name">icon-merge</span>          <span class="i-code">0xe833</span></td>
+                    <td title="Code: 0xe805" class="the-icons span3"><i class="icon-tag"></i>               <span class="i-name">icon-tag</span>            <span class="i-code">0xe805</span></td>
+                    <td title="Code: 0xe806" class="the-icons span3"><i class="icon-lock"></i>              <span class="i-name">icon-lock</span>           <span class="i-code">0xe806</span></td>
+                    <td title="Code: 0xe807" class="the-icons span3"><i class="icon-unlock"></i>            <span class="i-name">icon-unlock</span>         <span class="i-code">0xe807</span></td>
+                  </tr>     
+                  <tr class="row"> 
+                    <td title="Code: 0xe800" class="the-icons span3"><i class="icon-delete"></i>            <span class="i-name">icon-delete</span>         <span class="i-code">0xe800</span></td>
+                    <td title="Code: 0xe800" class="the-icons span3"><i class="icon-false"></i>             <span class="i-name">icon-false</span>          <span class="i-code">0xe800</span></td>
+                    <td title="Code: 0xe801" class="the-icons span3"><i class="icon-ok"></i>                <span class="i-name">icon-ok</span>             <span class="i-code">0xe801</span></td>
+                    <td title="Code: 0xe801" class="the-icons span3"><i class="icon-true"></i>              <span class="i-name">icon-true</span>           <span class="i-code">0xe801</span></td>
+                    <td title="Code: 0xe80f" class="the-icons span3"><i class="icon-group"></i>             <span class="i-name">icon-group</span>          <span class="i-code">0xe80f</span></td>
+                  </tr>     
+                  <tr class="row"> 
+                    <td title="Code: 0xe82d" class="the-icons span3"><i class="icon-hg"></i>                <span class="i-name">icon-hg</span>             <span class="i-code">0xe82d</span></td>
+                    <td title="Code: 0xe82a" class="the-icons span3"><i class="icon-git"></i>               <span class="i-name">icon-git</span>            <span class="i-code">0xe82a</span></td>
+                    <td title="Code: 0xe82e" class="the-icons span3"><i class="icon-svn"></i>               <span class="i-name">icon-svn</span>            <span class="i-code">0xe82e</span></td>
+                    <td title="Code: 0xe810" class="the-icons span3"><i class="icon-folder"></i>            <span class="i-name">icon-folder</span>         <span class="i-code">0xe810</span></td>
+                    <td title="Code: 0xe831" class="the-icons span3"><i class="icon-rhodecode"></i>         <span class="i-name">icon-rhodecode</span>      <span class="i-code">0xe831</span></td>
+                  </tr>     
+                  <tr class="row"> 
+                    <td title="Code: 0xe812" class="the-icons span3"><i class="icon-more"></i>              <span class="i-name">icon-more</span>           <span class="i-code">0xe812</span></td>
+                    <td title="Code: 0xe802" class="the-icons span3"><i class="icon-comment"></i>           <span class="i-name">icon-comment</span>        <span class="i-code">0xe802</span></td>
+                    <td title="Code: 0xe82f" class="the-icons span3"><i class="icon-comment-add"></i>       <span class="i-name">icon-comment-add</span>    <span class="i-code">0xe82f</span></td>
+                    <td title="Code: 0xe830" class="the-icons span3"><i class="icon-comment-toggle"></i>    <span class="i-name">icon-comment-toggle</span> <span class="i-code">0xe830</span></td>
+                    <td title="Code: 0xe808" class="the-icons span3"><i class="icon-feed"></i>              <span class="i-name">icon-feed</span>           <span class="i-code">0xe808</span></td>
                   </tr>
                   <tr class="row">
-                    <td title="Code: 0xe808" class="the-icons span3"><i class="icon-delete"></i> <span class="i-name">icon-delete</span><span class="i-code">0xe808</span></td>
-                    <td title="Code: 0xe808" class="the-icons span3"><i class="icon-false"></i> <span class="i-name">icon-false</span><span class="i-code">0xe808</span></td>
-                    <td title="Code: 0xe809" class="the-icons span3"><i class="icon-ok"></i> <span class="i-name">icon-ok</span><span class="i-code">0xe809</span></td>
-                    <td title="Code: 0xe809" class="the-icons span3"><i class="icon-true"></i> <span class="i-name">icon-true</span><span class="i-code">0xe809</span></td>
-                  </tr>
-                  <tr class="row">
-                    <td title="Code: 0xe80c" class="the-icons span3"><i class="icon-right"></i> <span class="i-name">icon-right</span><span class="i-code">0xe80c</span></td>
-                    <td title="Code: 0xe80d" class="the-icons span3"><i class="icon-left"></i> <span class="i-name">icon-left</span><span class="i-code">0xe80d</span></td>
-                    <td title="Code: 0xe80e" class="the-icons span3"><i class="icon-arrow_down"></i> <span class="i-name">icon-arrow_down</span><span class="i-code">0xe80e</span></td>
-                    <td title="Code: 0xe80f" class="the-icons span3"><i class="icon-git"></i> <span class="i-name">icon-git</span><span class="i-code">0xe80f</span></td>
-                  </tr>
-                  <tr class="row">
-                    <td title="Code: 0xe810" class="the-icons span3"><i class="icon-hg"></i> <span class="i-name">icon-hg</span><span class="i-code">0xe810</span></td>
-                    <td title="Code: 0xe811" class="the-icons span3"><i class="icon-svn"></i> <span class="i-name">icon-svn</span><span class="i-code">0xe811</span></td>
-                    <td title="Code: 0xe812" class="the-icons span3"><i class="icon-group"></i> <span class="i-name">icon-group</span><span class="i-code">0xe812</span></td>
-                    <td title="Code: 0xe813" class="the-icons span3"><i class="icon-folder"></i> <span class="i-name">icon-folder</span><span class="i-code">0xe813</span></td>
-                  </tr>
-                  <tr class="row">
-                    <td title="Code: 0xe814" class="the-icons span3"><i class="icon-fork"></i> <span class="i-name">icon-fork</span><span class="i-code">0xe814</span></td>
-                    <td title="Code: 0xe815" class="the-icons span3"><i class="icon-more"></i> <span class="i-name">icon-more</span><span class="i-code">0xe815</span></td>
-                    <td title="Code: 0xe80a" class="the-icons span3"><i class="icon-comment"></i> <span class="i-name">icon-comment</span><span class="i-code">0xe80a</span></td>
-                    <td title="Code: 0xe80b" class="the-icons span3"><i class="icon-feed"></i> <span class="i-name">icon-feed</span><span class="i-code">0xe80b</span></td>
+                    <td title="Code: 0xe80a" class="the-icons span3"><i class="icon-right"></i>             <span class="i-name">icon-right</span>          <span class="i-code">0xe80a</span></td>
+                    <td title="Code: 0xe809" class="the-icons span3"><i class="icon-left"></i>              <span class="i-name">icon-left</span>           <span class="i-code">0xe809</span></td>
+                    <td title="Code: 0xe80b" class="the-icons span3"><i class="icon-arrow_down"></i>        <span class="i-name">icon-arrow_down</span>     <span class="i-code">0xe80b</span></td>
+                    <td title="Code: 0xe832" class="the-icons span3"><i class="icon-arrow_up"></i>          <span class="i-name">icon-arrow_up</span>       <span class="i-code">0xe832</span></td>
+                    <td></td>
                   </tr>
                 </div>
             </table>

rhodecode/templates/debug_style/index.html

@@ -56,6 +56,7 b''
           <li class="${'active' if c.active=='forms' else ''}"><a href="${h.url('debug_style_template', t_path='forms.html')}">${_('Forms')}</a></li>
           <li class="${'active' if c.active=='buttons' else ''}"><a href="${h.url('debug_style_template', t_path='buttons.html')}">${_('Buttons')}</a></li>
           <li class="${'active' if c.active=='labels' else ''}"><a href="${h.url('debug_style_template', t_path='labels.html')}">${_('Labels')}</a></li>
+          <li class="${'active' if c.active=='alerts' else ''}"><a href="${h.url('debug_style_template', t_path='alerts.html')}">${_('Alerts')}</a></li>
           <li class="${'active' if c.active=='tables' else ''}"><a href="${h.url('debug_style_template', t_path='tables.html')}">${_('Tables')}</a></li>
           <li class="${'active' if c.active=='tables-wide' else ''}"><a href="${h.url('debug_style_template', t_path='tables-wide.html')}">${_('Tables wide')}</a></li>
           <li class="${'active' if c.active=='collapsable-content' else ''}"><a href="${h.url('debug_style_template', t_path='collapsable-content.html')}">${_('Collapsable Content')}</a></li>

rhodecode/templates/debug_style/labels.html

@@ -19,65 +19,45 b''
       ${self.sidebar()}
 
       <div class="main-content">
-
-        <h2>Label</h2>
-
+        <h2>Labels</h2>
+  
         <h3>Labels used for tags, branches and bookmarks</h3>
+  
+        <div class="bs-example">
+          <ul class="metatag-list">
+            <li>
+              <span class="tagtag tag" title="Tag tip">
+                <a href="/fake-link"><i class="icon-tag"></i>tip</a>
+              </span>
+            </li>
+            <li>
+              <span class="branchtag tag" title="Branch default">
+               <a href="/fake-link"><i class="icon-code-fork"></i>default</a>
+              </span>
+            </li>
+            <li>
+              <span class="bookmarktag tag" title="Bookmark example">
+               <a href="/fake-link"><i class="icon-bookmark"></i>example</a>
+              </span>
+            </li>
+          </ul>
 
-        <ul>
-          <li>
-            <span class="tagtag tag" title="Tag tip">
-              <a href="/fake-link"><i class="icon-tag"></i>tip</a>
-            </span>
-          </li>
-          <li>
-            <span class="branchtag tag" title="Branch default">
-             <a href="/fake-link"><i class="icon-code-fork"></i>default</a>
-            </span>
-          </li>
-          <li>
-            <span class="bookmarktag tag" title="Bookmark example">
-             <a href="/fake-link"><i class="icon-bookmark"></i>example</a>
-            </span>
-          </li>
-        </ul>
+        </div>
 
         <h3>Labels used in tables</h3>
-
-        <ul class="metatag-list">
-            <li>[default] <span class="metatag" tag="default">default</span></li>
-            <li>[featured] <span class="metatag" tag="featured">featured</span></li>
-            <li>[stale] <span class="metatag" tag="stale">stale</span></li>
-            <li>[dead] <span class="metatag" tag="dead">dead</span></li>
-            <li>[lang =&gt; lang] <span class="metatag" tag="lang">lang</span></li>
-            <li>[license =&gt; License] <span class="metatag" tag="license"><a href="http://www.opensource.org/licenses/License">License</a></span></li>
-            <li>[requires =&gt; Repo] <span class="metatag" tag="requires">requires =&gt; <a href="#">Repo</a></span></li>
-            <li>[recommends =&gt; Repo] <span class="metatag" tag="recommends">recommends =&gt; <a href="#">Repo</a></span></li>
-            <li>[see =&gt; URI] <span class="metatag" tag="see">see =&gt; <a href="#">URI</a></span></li>
-        </ul>
-
-        <h3>Flash Messages</h3>
-          <div class="flash_msg">
-
-            <div class="alert alert-dismissable alert-success">
-              <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
-              Updated VCS settings
-            </div>
-            <div class="alert alert-dismissable alert-warning">
-              <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
-              Updated VCS settings
-            </div>
-            <div class="alert alert-dismissable alert-error">
-              <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
-              Updated VCS settings
-            </div>
-            <div class="alert alert-dismissable alert">
-              <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
-              Updated VCS settings
-            </div>
-
-
-</div>
+        <div class="bs-example">
+          <ul class="metatag-list">
+              <li>[default] <span class="metatag" tag="default">default</span></li>
+              <li>[featured] <span class="metatag" tag="featured">featured</span></li>
+              <li>[stale] <span class="metatag" tag="stale">stale</span></li>
+              <li>[dead] <span class="metatag" tag="dead">dead</span></li>
+              <li>[lang =&gt; lang] <span class="metatag" tag="lang">lang</span></li>
+              <li>[license =&gt; License] <span class="metatag" tag="license"><a href="http://www.opensource.org/licenses/License">License</a></span></li>
+              <li>[requires =&gt; Repo] <span class="metatag" tag="requires">requires =&gt; <a href="#">Repo</a></span></li>
+              <li>[recommends =&gt; Repo] <span class="metatag" tag="recommends">recommends =&gt; <a href="#">Repo</a></span></li>
+              <li>[see =&gt; URI] <span class="metatag" tag="see">see =&gt; <a href="#">URI</a></span></li>
+          </ul>
+        </div>
       </div>  <!-- .main-content  -->
     </div>
   </div> <!-- .box -->

rhodecode/templates/errors/error_document.html

@@ -22,7 +22,7 b''
         <script type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script>
     </head>
     <body>
-        <%include file="/base/flash_msg.html"/>
+        <% messages = h.flash.pop_messages() %>
 
         <div class="wrapper error_page">
             <div class="sidebar">
@@ -35,6 +35,11 b''
                     </span><br/>
                     ${c.error_message} | <span class="error_message">${c.error_explanation}</span>
                 </h1>
+                % if messages:
+                    % for message in messages:
+                        <div class="alert alert-${message.category}">${message}</div>
+                    % endfor
+                % endif    
                 %if c.redirect_time:
                     <p>${_('You will be redirected to %s in %s seconds') % (c.redirect_module,c.redirect_time)}</p>
                 %endif

rhodecode/templates/files/base.html

@@ -1,7 +1,7 b''
 <%def name="refs(commit)">
     %if commit.merge:
         <span class="mergetag tag">
-         ${_('merge')}
+         <i class="icon-merge">${_('merge')}</i>
         </span>
     %endif
 

rhodecode/templates/files/files.html

@@ -88,7 +88,7 b''
             if (metadataRequest && metadataRequest.readyState != 4) {
                 metadataRequest.abort();
             }
-            if (source_page) {
+            if (fileSourcePage) {
                 return false;
             }
 
@@ -143,47 +143,9 b''
                 $(this).hide();
             });
 
-
-            if (source_page) {
+            if (fileSourcePage) {
                 // variants for with source code, not tree view
 
-                if (location.href.indexOf('#') != -1) {
-                    page_highlights = location.href.substring(location.href.indexOf('#') + 1).split('L');
-                    if (page_highlights.length == 2) {
-                        highlight_ranges = page_highlights[1].split(",");
-
-                        var h_lines = [];
-                        for (pos in highlight_ranges) {
-                            var _range = highlight_ranges[pos].split('-');
-                            if (_range.length == 2) {
-                                var start = parseInt(_range[0]);
-                                var end = parseInt(_range[1]);
-                                if (start < end) {
-                                    for (var i = start; i <= end; i++) {
-                                        h_lines.push(i);
-                                    }
-                                }
-                            }
-                            else {
-                                h_lines.push(parseInt(highlight_ranges[pos]));
-                            }
-                        }
-
-                        for (pos in h_lines) {
-                            // @comment-highlight-color
-                            $('#L' + h_lines[pos]).css('background-color', '#ffd887');
-                        }
-
-                        var _first_line = $('#L' + h_lines[0]).get(0);
-                        if (_first_line) {
-                            var line = $('#L' + h_lines[0]);
-                            if (line.length > 0){
-                                offsetScroll(line, 70);
-                            }
-                        }
-                    }
-                }
-
                 // select code link event
                 $("#hlcode").mouseup(getSelectionLink);
 

rhodecode/templates/files/files_browser.html

@@ -47,7 +47,3 b''
     </div>
 
 </div>
-
-<script>
-    var source_page = false;
-</script>

rhodecode/templates/files/files_browser_tree.html

@@ -27,17 +27,21 b''
           %for cnt,node in enumerate(c.file):
           <tr class="parity${cnt%2}">
             <td class="td-componentname">
-            %if node.is_submodule():
+            % if node.is_submodule():
               <span class="submodule-dir">
-                ${h.link_to_if(
-                    node.url.startswith('http://') or node.url.startswith('https://'),
-                    node.name, node.url)}
+                % if node.url.startswith('http://') or node.url.startswith('https://'):
+                  <a href="${node.url}">
+                      <i class="icon-folder browser-dir"></i>${node.name}
+                  </a>
+                % else:
+                  <i class="icon-folder browser-dir"></i>${node.name}
+                % endif
               </span>
-            %else:
+            % else:
               <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=h.safe_unicode(node.path))}" class="pjax-link">
                 <i class="${'icon-file browser-file' if node.is_file() else 'icon-folder browser-dir'}"></i>${node.name}
               </a>
-            %endif
+            % endif
             </td>
             %if node.is_file():
               <td class="td-size" data-attr-name="size">

rhodecode/templates/files/files_pjax.html

@@ -34,7 +34,10 b''
         % endif
 
     </div> <!--end summary-detail-->
-
+    <script>
+        // set the pageSource variable
+        var fileSourcePage = ${c.file_source_page};
+    </script>
     % if c.file.is_dir():
         <div id="commit-stats" class="sidebar-right">
             <%include file='file_tree_author_box.html'/>

rhodecode/templates/files/files_source.html

@@ -1,3 +1,4 b''
+<%namespace name="sourceblock" file="/codeblocks/source.html"/>
 
 <div id="codeblock" class="codeblock">
     <div class="codeblock-header">
@@ -51,12 +52,22 b''
            </div>
        %else:
         % if c.file.size < c.cut_off_limit:
-            %if c.annotate:
-              ${h.pygmentize_annotation(c.repo_name,c.file,linenos=True,anchorlinenos=True,lineanchors='L',cssclass="code-highlight")}
-            %elif c.renderer:
+            %if c.renderer and not c.annotate:
                 ${h.render(c.file.content, renderer=c.renderer)}
             %else:
-              ${h.pygmentize(c.file,linenos=True,anchorlinenos=True,lineanchors='L',cssclass="code-highlight")}
+                <table class="cb codehilite">
+                %if c.annotate:
+                  <% color_hasher = h.color_hasher() %>
+                  %for annotation, lines in c.annotated_lines:
+                    ${sourceblock.render_annotation_lines(annotation, lines, color_hasher)}
+                  %endfor
+                %else:
+                  %for line_num, tokens in enumerate(c.lines, 1):
+                    ${sourceblock.render_line(line_num, tokens)}
+                  %endfor
+                %endif
+                </table>
+              </div>
             %endif
         %else:
             ${_('File is too big to display')} ${h.link_to(_('Show as raw'),
@@ -64,8 +75,4 b''
         %endif
      %endif
     </div>
-</div>
-
-<script>
-    var source_page = true;
-</script>
+</div>
  No newline at end of file

rhodecode/templates/forks/fork.html

@@ -59,9 +59,11 b''
                  </div>
                  <div class="select">
                      ${h.select('repo_group','',c.repo_groups,class_="medium")}
-                     %if c.personal_repo_group:
-                         <a style="padding: 4px" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}</a>
-                     %endif
+                     % if c.personal_repo_group:
+                         <a class="btn" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">
+                             ${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}
+                         </a>
+                     % endif
                      <span class="help-block">${_('Optionally select a group to put this repository into.')}</span>
                  </div>
             </div>

rhodecode/templates/login.html

@@ -29,7 +29,6 b''
         </div>
         <%block name="above_login_button" />
         <div id="login" class="right-column">
-            <%include file="/base/flash_msg.html"/>
             <!-- login -->
             <div class="sign-in-title">
                 <h1>${_('Sign In')}</h1>
@@ -57,9 +56,21 b''
                     ${h.checkbox('remember', value=True, checked=defaults.get('remember'))}
                     <label class="checkbox" for="remember">${_('Remember me')}</label>
 
-                    <p class="links">
-                        ${h.link_to(_('Forgot your password?'), h.route_path('reset_password'))}
-                    </p>
+                    %if h.HasPermissionAny('hg.password_reset.enabled')():
+                        <p class="links">
+                            ${h.link_to(_('Forgot your password?'), h.route_path('reset_password'), class_='pwd_reset')}
+                        </p>
+                    %elif h.HasPermissionAny('hg.password_reset.hidden')():
+                        <p class="help-block">
+                            ${_('Password reset is disabled. Please contact ')}
+                            % if c.visual.rhodecode_support_url:
+                                <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>
+                                ${_('or')}
+                            % endif
+                            ${_('an administrator if you need help.')}
+                        </p>
+                            %endif
+                    
 
                     ${h.submit('sign_in', _('Sign In'), class_="btn sign-in")}
 

rhodecode/templates/password_reset.html

@@ -2,7 +2,7 b''
 <%inherit file="base/root.html"/>
 
 <%def name="title()">
-    ${_('Create an Account')}
+    ${_('Reset Password')}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
@@ -28,40 +28,52 b''
             <img class="sign-in-image" src="${h.asset('images/sign-in.png')}" alt="RhodeCode"/>
         </div>
 
-        <div id="register" class="right-column">
-            <%include file="/base/flash_msg.html"/>
-            <!-- login -->
-            <div class="sign-in-title">
-                <h1>${_('Reset your Password')}</h1>
-                <h4>${h.link_to(_("Go to the login page to sign in."), request.route_path('login'))}</h4>
+        %if h.HasPermissionAny('hg.password_reset.disabled')():
+            <div class="right-column">
+                <p>
+                    ${_('Password reset is disabled. Please contact ')}
+                    % if c.visual.rhodecode_support_url:
+                        <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>
+                        ${_('or')}
+                    % endif
+                    ${_('an administrator if you need help.')}
+                </p>
             </div>
-            <div class="inner form">
-                ${h.form(request.route_path('reset_password'), needs_csrf_token=False)}
-                    <label for="email">${_('Email Address')}:</label>
-                    ${h.text('email', defaults.get('email'))}
-                    %if 'email' in errors:
-                      <span class="error-message">${errors.get('email')}</span>
-                      <br />
-                    %endif
-
-                    %if captcha_active:
-                    <div class="login-captcha"
-                        <label for="email">${_('Captcha')}:</label>
-                        ${h.hidden('recaptcha_field')}
-                        <div id="recaptcha"></div>
-                        %if 'recaptcha_field' in errors:
-                          <span class="error-message">${errors.get('recaptcha_field')}</span>
+        %else:
+            <div id="register" class="right-column">
+                <!-- login -->
+                <div class="sign-in-title">
+                    <h1>${_('Reset your Password')}</h1>
+                    <h4>${h.link_to(_("Go to the login page to sign in."), request.route_path('login'))}</h4>
+                </div>
+                <div class="inner form">
+                    ${h.form(request.route_path('reset_password'), needs_csrf_token=False)}
+                        <label for="email">${_('Email Address')}:</label>
+                        ${h.text('email', defaults.get('email'))}
+                        %if 'email' in errors:
+                          <span class="error-message">${errors.get('email')}</span>
                           <br />
                         %endif
-                    </div>
-                    %endif
-
-                    ${h.submit('send', _('Send password reset email'), class_="btn sign-in")}
-                    <div class="activation_msg">${_('Password reset link will be sent to matching email address')}</div>
-
-                ${h.end_form()}
+    
+                        %if captcha_active:
+                        <div class="login-captcha"
+                            <label for="email">${_('Captcha')}:</label>
+                            ${h.hidden('recaptcha_field')}
+                            <div id="recaptcha"></div>
+                            %if 'recaptcha_field' in errors:
+                              <span class="error-message">${errors.get('recaptcha_field')}</span>
+                              <br />
+                            %endif
+                        </div>
+                        %endif
+    
+                        ${h.submit('send', _('Send password reset email'), class_="btn sign-in")}
+                        <div class="activation_msg">${_('Password reset link will be sent to matching email address')}</div>
+    
+                    ${h.end_form()}
+                </div>
             </div>
-        </div>
+        %endif
     </div>
 </div>
 

rhodecode/templates/pullrequests/pullrequest.html

@@ -111,7 +111,9 b''
                 </div>
                 <div id="reviewers" class="block-right pr-details-content reviewers">
                     ## members goes here, filled via JS based on initial selection !
+                    <input type="hidden" name="__start__" value="review_members:sequence">
                     <ul id="review_members" class="group_members"></ul>
+                    <input type="hidden" name="__end__" value="review_members:sequence">
                     <div id="add_reviewer_input" class='ac'>
                         <div class="reviewer_ac">
                             ${h.text('user', class_='ac-input', placeholder=_('Add reviewer'))}
@@ -439,13 +441,6 b''
   };
 
   var targetRepoChanged = function(repoData) {
-      // reset && add the reviewer based on selected repo
-      $('#review_members').html('');
-      addReviewMember(
-          repoData.user.user_id, repoData.user.firstname,
-          repoData.user.lastname, repoData.user.username,
-          repoData.user.gravatar_link);
-
       // generate new DESC of target repo displayed next to select
       $('#target_repo_desc').html(
           "<strong>${_('Destination repository')}</strong>: {0}".format(repoData['description'])
@@ -488,10 +483,12 b''
 
   $sourceRef.on('change', function(e){
     loadRepoRefDiffPreview();
+    loadDefaultReviewers();
   });
 
   $targetRef.on('change', function(e){
     loadRepoRefDiffPreview();
+    loadDefaultReviewers();
   });
 
   $targetRepo.on('change', function(e){
@@ -518,6 +515,36 b''
 
   });
 
+  var loadDefaultReviewers = function() {
+    if (loadDefaultReviewers._currentRequest) {
+        loadDefaultReviewers._currentRequest.abort();
+    }
+    var url = pyroutes.url('repo_default_reviewers_data', {'repo_name': targetRepoName});
+
+    var sourceRepo = $sourceRepo.eq(0).val();
+    var sourceRef = $sourceRef.eq(0).val().split(':');
+    var targetRepo = $targetRepo.eq(0).val();
+    var targetRef = $targetRef.eq(0).val().split(':');
+    url += '?source_repo=' + sourceRepo;
+    url += '&source_ref=' + sourceRef[2];
+    url += '&target_repo=' + targetRepo;
+    url += '&target_ref=' + targetRef[2];
+
+    loadDefaultReviewers._currentRequest = $.get(url)
+          .done(function(data) {
+            loadDefaultReviewers._currentRequest = null;
+
+            // reset && add the reviewer based on selected repo
+            $('#review_members').html('');
+            for (var i = 0; i < data.reviewers.length; i++) {
+              var reviewer = data.reviewers[i];
+              addReviewMember(
+                  reviewer.user_id, reviewer.firstname,
+                  reviewer.lastname, reviewer.username,
+                  reviewer.gravatar_link, reviewer.reasons);
+            }
+    });
+  };
   prButtonLock(true, "${_('Please select origin and destination')}");
 
   // auto-load on init, the target refs select2
@@ -532,6 +559,7 b''
       // in case we have a pre-selected value, use it now
       $sourceRef.select2('val', '${c.default_source_ref}');
       loadRepoRefDiffPreview();
+      loadDefaultReviewers();
   %endif
 
   ReviewerAutoComplete('user');

rhodecode/templates/pullrequests/pullrequest_show.html

@@ -47,8 +47,18 b''
         <div class="pr-details-title">
             ${_('Pull request #%s') % c.pull_request.pull_request_id} ${_('From')} ${h.format_date(c.pull_request.created_on)}
             %if c.allowed_to_update:
-              <span id="open_edit_pullrequest" class="block-right action_button">${_('Edit')}</span>
-              <span id="close_edit_pullrequest" class="block-right action_button" style="display: none;">${_('Close')}</span>
+              <div id="delete_pullrequest" class="pull-right action_button ${'' if c.allowed_to_delete else 'disabled' }" style="clear:inherit;padding: 0">
+                  % if c.allowed_to_delete:
+                      ${h.secure_form(url('pullrequest_delete', repo_name=c.pull_request.target_repo.repo_name, pull_request_id=c.pull_request.pull_request_id),method='delete')}
+                          ${h.submit('remove_%s' % c.pull_request.pull_request_id, _('Delete'),
+                        class_="btn btn-link btn-danger",onclick="return confirm('"+_('Confirm to delete this pull request')+"');")}
+                      ${h.end_form()}
+                  % else:
+                    ${_('Delete')}
+                  % endif
+              </div>
+              <div id="open_edit_pullrequest" class="pull-right action_button">${_('Edit')}</div>
+              <div id="close_edit_pullrequest" class="pull-right action_button" style="display: none;padding: 0">${_('Cancel edit')}</div>
             %endif
         </div>
 
@@ -100,6 +110,25 b''
                 </div>
             </div>
            </div>
+
+            ## Link to the shadow repository.
+            %if not c.pull_request.is_closed() and c.pull_request.shadow_merge_ref:
+                <div class="field">
+                    <div class="label-summary">
+                        <label>Merge:</label>
+                    </div>
+                    <div class="input">
+                        <div class="pr-mergeinfo">
+                            %if h.is_hg(c.pull_request.target_repo):
+                                <input type="text"  value="hg clone -u ${c.pull_request.shadow_merge_ref.name} ${c.shadow_clone_url} pull-request-${c.pull_request.pull_request_id}" readonly="readonly">
+                            %elif h.is_git(c.pull_request.target_repo):
+                                <input type="text"  value="git clone --branch ${c.pull_request.shadow_merge_ref.name} ${c.shadow_clone_url} pull-request-${c.pull_request.pull_request_id}" readonly="readonly">
+                            %endif
+                        </div>
+                    </div>
+                </div>
+            %endif
+
            <div class="field">
             <div class="label-summary">
                 <label>${_('Review')}:</label>
@@ -188,17 +217,27 b''
         </div>
         <div id="reviewers" class="block-right pr-details-content reviewers">
           ## members goes here !
+            <input type="hidden" name="__start__" value="review_members:sequence">
             <ul id="review_members" class="group_members">
-            %for member,status in c.pull_request_reviewers:
+            %for member,reasons,status in c.pull_request_reviewers:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip" title="${h.tooltip(h.commit_status_lbl(status[0][1].status if status else 'not_reviewed'))}">
                       <div class="${'flag_status %s' % (status[0][1].status if status else 'not_reviewed')} pull-left reviewer_member_status"></div>
                     </div>
                   <div id="reviewer_${member.user_id}_name" class="reviewer_name">
-                    ${self.gravatar_with_user(member.email, 16)} <div class="reviewer">(${_('owner') if c.pull_request.user_id == member.user_id else _('reviewer')})</div>
+                    ${self.gravatar_with_user(member.email, 16)}
                   </div>
-                  <input id="reviewer_${member.user_id}_input" type="hidden" value="${member.user_id}" name="review_members" />
+                  <input type="hidden" name="__start__" value="reviewer:mapping">
+                  <input type="hidden" name="__start__" value="reasons:sequence">
+                  %for reason in reasons:
+                  <div class="reviewer_reason">- ${reason}</div>
+                  <input type="hidden" name="reason" value="${reason}">
+
+                  %endfor
+                  <input type="hidden" name="__end__" value="reasons:sequence">
+                  <input id="reviewer_${member.user_id}_input" type="hidden" value="${member.user_id}" name="user_id" />
+                  <input type="hidden" name="__end__" value="reviewer:mapping">
                   %if c.allowed_to_update:
                   <div class="reviewer_member_remove action_button" onclick="removeReviewMember(${member.user_id}, true)" style="visibility: hidden;">
                       <i class="icon-remove-sign" ></i>
@@ -208,6 +247,7 b''
               </li>
             %endfor
             </ul>
+            <input type="hidden" name="__end__" value="review_members:sequence">
           %if not c.pull_request.is_closed():
           <div id="add_reviewer_input" class='ac' style="display: none;">
             %if c.allowed_to_update:
@@ -259,143 +299,18 b''
                 </div>
               % if not c.missing_commits:
                 <%include file="/compare/compare_commits.html" />
-                ## FILES
-                <div class="cs_files_title">
-                    <span class="cs_files_expand">
-                        <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-                    </span>
-                    <h2>
-                        ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-                    </h2>
-                </div>
-              % endif
               <div class="cs_files">
-              %if not c.files and not c.missing_commits:
-                  <span class="empty_data">${_('No files')}</span>
-              %endif
-              <table class="compare_view_files">
-              <%namespace name="diff_block" file="/changeset/diff_block.html"/>
-              %for FID, change, path, stats in c.files:
-                  <tr class="cs_${change} collapse_file" fid="${FID}">
-                      <td class="cs_icon_td">
-                          <span class="collapse_file_icon" fid="${FID}"></span>
-                      </td>
-                      <td class="cs_icon_td">
-                          <div class="flag_status not_reviewed hidden"></div>
-                      </td>
-                      <td class="cs_${change}" id="a_${FID}">
-                          <div class="node">
-                              <a href="#a_${FID}">
-                                  <i class="icon-file-${change.lower()}"></i>
-                                  ${h.safe_unicode(path)}
-                              </a>
-                          </div>
-                      </td>
-                      <td>
-                          <div class="changes pull-right">${h.fancy_file_stats(stats)}</div>
-                          <div class="comment-bubble pull-right" data-path="${path}">
-                            <i class="icon-comment"></i>
-                          </div>
-                      </td>
-                  </tr>
-                  <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-                      <td></td>
-                      <td></td>
-                      <td class="cs_${change}">
-                          %if c.target_repo.repo_name == c.repo_name:
-                              ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), c.target_ref, c.source_ref, change)}
-                          %else:
-                              ## this is slightly different case later, since the other repo can have this
-                              ## file in other state than the origin repo
-                              ${diff_block.diff_menu(c.target_repo.repo_name, h.safe_unicode(path), c.target_ref, c.source_ref, change)}
-                          %endif
-                      </td>
-                      <td class="td-actions rc-form">
-                        <div data-comment-id="${FID}" class="btn-link show-inline-comments comments-visible">
-                          <span class="comments-show">${_('Show comments')}</span>
-                          <span class="comments-hide">${_('Hide comments')}</span>
-                        </div>
-                      </td>
-                  </tr>
-                  <tr id="tr_${FID}">
-                    <td></td>
-                    <td></td>
-                    <td class="injected_diff" colspan="2">
-                        ${diff_block.diff_block_simple([c.changes[FID]])}
-                    </td>
-                  </tr>
+                <%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
+                ${cbdiffs.render_diffset_menu()}
+                ${cbdiffs.render_diffset(
+                  c.diffset, use_comments=True,
+                  collapse_when_files_over=30,
+                  disable_new_comments=c.pull_request.is_closed())}
 
-                ## Loop through inline comments
-                  % if c.outdated_comments.get(path,False):
-                    <tr class="outdated">
-                      <td></td>
-                      <td></td>
-                      <td colspan="2">
-                        <p>${_('Outdated Inline Comments')}:</p>
-                      </td>
-                    </tr>
-                    <tr class="outdated">
-                      <td></td>
-                      <td></td>
-                      <td colspan="2" class="outdated_comment_block">
-                      % for line, comments in c.outdated_comments[path].iteritems():
-                          <div class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">
-                            % for co in comments:
-                              ${comment.comment_block_outdated(co)}
-                            % endfor
-                          </div>
-                      % endfor
-                      </td>
-                    </tr>
-                  % endif
-              %endfor
-              ## Loop through inline comments for deleted files
-              %for path in c.deleted_files:
-                <tr class="outdated deleted">
-                  <td></td>
-                  <td></td>
-                  <td>${path}</td>
-                </tr>
-                <tr class="outdated deleted">
-                  <td></td>
-                  <td></td>
-                  <td>(${_('Removed')})</td>
-                </tr>
-                % if path in c.outdated_comments:
-                  <tr class="outdated deleted">
-                    <td></td>
-                    <td></td>
-                    <td colspan="2">
-                      <p>${_('Outdated Inline Comments')}:</p>
-                    </td>
-                  </tr>
-                  <tr class="outdated">
-                    <td></td>
-                    <td></td>
-                    <td colspan="2" class="outdated_comment_block">
-                    % for line, comments in c.outdated_comments[path].iteritems():
-                        <div class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">
-                          % for co in comments:
-                            ${comment.comment_block_outdated(co)}
-                          % endfor
-                        </div>
-                    % endfor
-                    </td>
-                  </tr>
-                % endif
-              %endfor
-              </table>
-              </div>
-              % if c.limited_diff:
-              <h5>${_('Commit was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a huge diff might take some time and resources")}')">${_('Show full diff')}</a></h5>
+          </div>
               % endif
-          </div>
       </div>
 
-      % if c.limited_diff:
-        <p>${_('Commit was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a huge diff might take some time and resources")}')">${_('Show full diff')}</a></p>
-      % endif
-
       ## template for inline comment form
       <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
       ${comment.comment_inline_form()}
@@ -427,6 +342,7 b''
             var PRDetails = {
               editButton: $('#open_edit_pullrequest'),
               closeButton: $('#close_edit_pullrequest'),
+              deleteButton: $('#delete_pullrequest'),
               viewFields: $('#pr-desc, #pr-title'),
               editFields: $('#pr-desc-edit, #pr-title-edit, #pr-save'),
 
@@ -439,11 +355,15 b''
               edit: function(event) {
                 this.viewFields.hide();
                 this.editButton.hide();
+                this.deleteButton.hide();
+                this.closeButton.show();
                 this.editFields.show();
                 codeMirrorInstance.refresh();
               },
 
               view: function(event) {
+                this.editButton.show();
+                this.deleteButton.show();
                 this.editFields.hide();
                 this.closeButton.hide();
                 this.viewFields.show();
@@ -474,7 +394,7 b''
                 this.closeButton.hide();
                 this.addButton.hide();
                 this.removeButtons.css('visibility', 'hidden');
-              }
+              },
             };
 
             PRDetails.init();
@@ -569,16 +489,16 b''
             $('.show-inline-comments').on('click', function(e){
                 var boxid = $(this).attr('data-comment-id');
                 var button = $(this);
-  
+
                 if(button.hasClass("comments-visible")) {
                   $('#{0} .inline-comments'.format(boxid)).each(function(index){
                     $(this).hide();
-                  })
+                  });
                   button.removeClass("comments-visible");
                 } else {
                   $('#{0} .inline-comments'.format(boxid)).each(function(index){
                     $(this).show();
-                  })
+                  });
                   button.addClass("comments-visible");
                 }
             });

rhodecode/templates/register.html

@@ -29,7 +29,6 b''
         </div>
         <%block name="above_register_button" />
         <div id="register" class="right-column">
-            <%include file="/base/flash_msg.html"/>
             <!-- login -->
             <div class="sign-in-title">
                 <h1>${_('Create an account')}</h1>

rhodecode/tests/__init__.py

@@ -224,9 +224,11 b' def assert_session_flash(response=None, '
         raise ValueError("Parameter msg is required.")
 
     messages = flash.pop_messages()
+    msg = _eval_if_lazy(msg)
+
+    assert messages, 'unable to find message `%s` in empty flash list' % msg
     message = messages[0]
 
-    msg = _eval_if_lazy(msg)
     message_text = _eval_if_lazy(message.message)
 
     if msg not in message_text:

rhodecode/tests/config/test_sanitize_settings.py

@@ -115,10 +115,11 b' class TestSanitizeVcsSettings(object):'
     _string_settings = [
         ('vcs.svn.compatible_version', ''),
         ('git_rev_filter', '--all'),
-        ('vcs.hooks.protocol', 'pyro4'),
+        ('vcs.hooks.protocol', 'http'),
+        ('vcs.scm_app_implementation', 'http'),
         ('vcs.server', ''),
         ('vcs.server.log_level', 'debug'),
-        ('vcs.server.protocol', 'pyro4'),
+        ('vcs.server.protocol', 'http'),
     ]
 
     _list_settings = [

rhodecode/tests/controllers/test_pullrequests.py

@@ -27,7 +27,7 b' from rhodecode.model.pull_request import'
 from rhodecode.tests import assert_session_flash
 
 
-def test_merge_pull_request_renders_failure_reason(user_regular):
+def test_merge_pull_request_renders_failure_reason(app, user_regular):
     pull_request = mock.Mock()
     controller = pullrequests.PullrequestsController()
     model_patcher = mock.patch.multiple(

rhodecode/tests/database/conftest.py

@@ -18,7 +18,7 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-from subprocess import Popen, PIPE
+from subprocess32 import Popen, PIPE
 import os
 import shutil
 import sys

rhodecode/tests/events/test_repo.py

@@ -45,6 +45,7 b' def scm_extras(user_regular, repo_stub):'
         'make_lock': None,
         'locked_by': [None],
         'commit_ids': ['a' * 40] * 3,
+        'is_shadow_repo': False,
     })
     return extras
 

rhodecode/tests/fixture.py

@@ -76,8 +76,8 b' class TestINI(object):'
 
         for data in self.ini_params:
             section, ini_params = data.items()[0]
-            key, val = ini_params.items()[0]
-            config[section][key] = val
+            for key, val in ini_params.items():
+                config[section][key] = val
         with tempfile.NamedTemporaryFile(
                 prefix=self.new_path_prefix, suffix='.ini', dir=self._dir,
                 delete=False) as new_ini_file:

rhodecode/tests/functional/test_admin_my_account.py

@@ -85,14 +85,13 b' class TestMyAccountController(TestContro'
     def test_my_account_my_pullrequests(self, pr_util):
         self.log_user()
         response = self.app.get(url('my_account_pullrequests'))
-        response.mustcontain('You currently have no open pull requests.')
+        response.mustcontain('There are currently no open pull '
+                             'requests requiring your participation.')
 
         pr = pr_util.create_pull_request(title='TestMyAccountPR')
         response = self.app.get(url('my_account_pullrequests'))
-        response.mustcontain('There are currently no open pull requests '
-                             'requiring your participation')
-
-        response.mustcontain('#%s: TestMyAccountPR' % pr.pull_request_id)
+        response.mustcontain('"name_raw": %s' % pr.pull_request_id)
+        response.mustcontain('TestMyAccountPR')
 
     def test_my_account_my_emails(self):
         self.log_user()

rhodecode/tests/functional/test_admin_permissions.py

@@ -40,22 +40,22 b' class TestAdminPermissionsController(Tes'
         self.app.get(url('admin_permissions_application'))
 
     @pytest.mark.parametrize(
-        'anonymous, default_register, default_register_message,'
+        'anonymous, default_register, default_register_message, default_password_reset,' 
         'default_extern_activate, expect_error, expect_form_error', [
-            (True, 'hg.register.none', '', 'hg.extern_activate.manual',
+            (True, 'hg.register.none', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
-            (True, 'hg.register.manual_activate', '', 'hg.extern_activate.auto',
+            (True, 'hg.register.manual_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.auto',
              False, False),
-            (True, 'hg.register.auto_activate', '', 'hg.extern_activate.manual',
+            (True, 'hg.register.auto_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
-            (True, 'hg.register.auto_activate', '', 'hg.extern_activate.manual',
+            (True, 'hg.register.auto_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
-            (True, 'hg.register.XXX', '', 'hg.extern_activate.manual',
+            (True, 'hg.register.XXX', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, True),
-            (True, '', '', '', True, False),
+            (True, '', '', 'hg.password_reset.enabled', '', True, False),
         ])
     def test_update_application_permissions(
-            self, anonymous, default_register, default_register_message,
+            self, anonymous, default_register, default_register_message, default_password_reset,
             default_extern_activate, expect_error, expect_form_error):
 
         self.log_user()
@@ -66,6 +66,7 b' class TestAdminPermissionsController(Tes'
             'anonymous': anonymous,
             'default_register': default_register,
             'default_register_message': default_register_message,
+            'default_password_reset': default_password_reset,
             'default_extern_activate': default_extern_activate,
         }
         response = self.app.post(url('admin_permissions_application'),

rhodecode/tests/functional/test_admin_settings.py

@@ -195,6 +195,8 b' class TestAdminSettingsGlobal:'
             'rhodecode_post_code': '',
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '',
+            'rhodecode_create_personal_repo_group': False,
+            'rhodecode_personal_repo_group_pattern': '${username}',
         }
         params.update(settings)
         response = self.app.post(url('admin_settings_global'), params=params)
@@ -494,6 +496,14 b' class TestAdminSettingsIssueTracker:'
         response = self.app.get(url('admin_settings_issuetracker'))
         assert response.status_code == 200
 
+    def test_add_empty_issuetracker_pattern(
+            self, request, autologin_user, csrf_token):
+        post_url = url('admin_settings_issuetracker_save')
+        post_data = {
+            'csrf_token': csrf_token
+        }
+        self.app.post(post_url, post_data, status=302)
+
     def test_add_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         pattern = 'issuetracker_pat'

rhodecode/tests/functional/test_admin_user_groups.py

@@ -36,7 +36,7 b' class TestAdminUsersGroupsController(Tes'
     def test_index(self):
         self.log_user()
         response = self.app.get(url('users_groups'))
-        response.status_int == 200
+        assert response.status_int == 200
 
     def test_create(self):
         self.log_user()
@@ -148,19 +148,21 b' class TestAdminUsersGroupsController(Tes'
 
         fixture.destroy_user_group(users_group_name)
 
-    def test_edit(self):
+    def test_edit_autocomplete(self):
         self.log_user()
         ug = fixture.create_user_group(TEST_USER_GROUP, skip_if_exists=True)
         response = self.app.get(
             url('edit_users_group', user_group_id=ug.users_group_id))
         fixture.destroy_user_group(TEST_USER_GROUP)
 
-    def test_edit_user_group_members(self):
+    def test_edit_user_group_autocomplete_members(self, xhr_header):
         self.log_user()
         ug = fixture.create_user_group(TEST_USER_GROUP, skip_if_exists=True)
         response = self.app.get(
-            url('edit_user_group_members', user_group_id=ug.users_group_id))
-        response.mustcontain('No members yet')
+            url('edit_user_group_members', user_group_id=ug.users_group_id),
+            extra_environ=xhr_header)
+
+        assert response.body == '{"members": []}'
         fixture.destroy_user_group(TEST_USER_GROUP)
 
     def test_usergroup_escape(self):
@@ -181,7 +183,7 b' class TestAdminUsersGroupsController(Tes'
             'csrf_token': self.csrf_token
         }
 
-        response = self.app.post(url('users_groups'), data)
+        self.app.post(url('users_groups'), data)
         response = self.app.get(url('users_groups'))
 
         response.mustcontain(
@@ -190,3 +192,42 b' class TestAdminUsersGroupsController(Tes'
         response.mustcontain(
             '<img src="/image2" onload="'
             'alert('Hello, World!');">')
+
+    def test_update_members_from_user_ids(self, user_regular):
+        uid = user_regular.user_id
+        username = user_regular.username
+        self.log_user()
+
+        user_group = fixture.create_user_group('test_gr_ids')
+        assert user_group.members == []
+        assert user_group.user != user_regular
+        expected_active_state = not user_group.users_group_active
+
+        form_data = [
+            ('csrf_token', self.csrf_token),
+            ('_method', 'put'),
+            ('user', username),
+            ('users_group_name', 'changed_name'),
+            ('users_group_active', expected_active_state),
+            ('user_group_description', 'changed_description'),
+
+            ('__start__', 'user_group_members:sequence'),
+            ('__start__', 'member:mapping'),
+            ('member_user_id', uid),
+            ('type', 'existing'),
+            ('__end__', 'member:mapping'),
+            ('__end__', 'user_group_members:sequence'),
+        ]
+        ugid = user_group.users_group_id
+        self.app.post(url('update_users_group', user_group_id=ugid), form_data)
+
+        user_group = UserGroup.get(ugid)
+        assert user_group
+
+        assert user_group.members[0].user_id == uid
+        assert user_group.user_id == uid
+        assert 'changed_name' in user_group.users_group_name
+        assert 'changed_description' in user_group.user_group_description
+        assert user_group.users_group_active == expected_active_state
+
+        fixture.destroy_user_group(user_group)

rhodecode/tests/functional/test_changelog.py

@@ -82,8 +82,7 b' class TestChangelogController(TestContro'
         assert expected_url in response.location
         response = response.follow()
         expected_warning = 'Branch {} is not found.'.format(branch)
-        assert_response = AssertResponse(response)
-        assert_response.element_contains('.alert-warning', expected_warning)
+        assert expected_warning in response.body
 
     def assert_commits_on_page(self, response, indexes):
         found_indexes = [int(idx) for idx in MATCH_HASH.findall(response.body)]

rhodecode/tests/functional/test_changeset.py

@@ -82,7 +82,7 b' class TestChangesetController(object):'
             response.mustcontain('new file 100644')
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
-        self._check_diff_menus(response, right_menu=True)
+        self._check_new_diff_menus(response, right_menu=True)
 
     def test_commit_range_page_different_ops(self, backend):
         commit_id_range = {
@@ -104,14 +104,17 b' class TestChangesetController(object):'
 
         response.mustcontain(_shorten_commit_id(commit_ids[0]))
         response.mustcontain(_shorten_commit_id(commit_ids[1]))
-        
+
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
-            response.mustcontain('34 files changed: 1184 inserted, 311 deleted')
+            response.mustcontain('1 file changed: 5 inserted, 1 deleted')
+            response.mustcontain('12 files changed: 236 inserted, 22 deleted')
+            response.mustcontain('21 files changed: 943 inserted, 288 deleted')
         else:
             response.mustcontain('new file 100644')
-            response.mustcontain('33 files changed: 1165 inserted, 308 deleted')
+            response.mustcontain('12 files changed: 222 inserted, 20 deleted')
+            response.mustcontain('21 files changed: 943 inserted, 288 deleted')
 
         # files op files
         response.mustcontain('File no longer present at commit: %s' %
@@ -119,7 +122,7 b' class TestChangesetController(object):'
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
-        self._check_diff_menus(response)
+        self._check_new_diff_menus(response)
 
     def test_combined_compare_commit_page_different_ops(self, backend):
         commit_id_range = {
@@ -146,7 +149,7 b' class TestChangesetController(object):'
         # files op files
         response.mustcontain('File no longer present at commit: %s' %
                              _shorten_commit_id(commit_ids[1]))
-        
+
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
@@ -158,7 +161,7 b' class TestChangesetController(object):'
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
-        self._check_diff_menus(response)
+        self._check_new_diff_menus(response)
 
     def test_changeset_range(self, backend):
         self._check_changeset_range(
@@ -273,7 +276,7 b' Added a symlink'
 """ + diffs['svn'],
     }
 
-    def _check_diff_menus(self, response, right_menu=False):
+    def _check_diff_menus(self, response, right_menu=False,):
         # diff menus
         for elem in ['Show File', 'Unified Diff', 'Side-by-side Diff',
                      'Raw Diff', 'Download Diff']:
@@ -284,3 +287,16 b' Added a symlink'
             for elem in ['Ignore whitespace', 'Increase context',
                          'Hide comments']:
                 response.mustcontain(elem)
+
+
+    def _check_new_diff_menus(self, response, right_menu=False,):
+        # diff menus
+        for elem in ['Show file before', 'Show file after',
+                     'Raw diff', 'Download diff']:
+            response.mustcontain(elem)
+
+        # right pane diff menus
+        if right_menu:
+            for elem in ['Ignore whitespace', 'Increase context',
+                         'Hide comments']:
+                response.mustcontain(elem)

rhodecode/tests/functional/test_commit_comments.py

@@ -109,11 +109,17 b' class TestCommitCommentsController(TestC'
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, 0, ChangesetComment.query().count())
-        response.mustcontain(
-            '''class="inline-comment-placeholder" '''
-            '''path="vcs/web/simplevcs/views/repository.py" '''
-            '''target_id="vcswebsimplevcsviewsrepositorypy"'''
-        )
+
+        if backend.alias == 'svn':
+            response.mustcontain(
+                '''data-f-path="vcs/commands/summary.py" '''
+                '''id="a_c--ad05457a43f8"'''
+            )
+        else:
+            response.mustcontain(
+                '''data-f-path="vcs/backends/hg.py" '''
+                '''id="a_c--9c390eb52cd6"'''
+            )
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
@@ -271,7 +277,6 b' def assert_comment_links(response, comme'
                                      inline_comments) % inline_comments
     if inline_comments:
         response.mustcontain(
-            '<a href="#inline-comments" '
-            'id="inline-comments-counter">%s</a>' % inline_comments_text)
+            'id="inline-comments-counter">%s</' % inline_comments_text)
     else:
         response.mustcontain(inline_comments_text)

rhodecode/tests/functional/test_compare.py

@@ -20,6 +20,7 b''
 
 import mock
 import pytest
+import lxml.html
 
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
@@ -609,9 +610,12 b' class ComparePage(AssertResponse):'
     """
 
     def contains_file_links_and_anchors(self, files):
+        doc = lxml.html.fromstring(self.response.body)
         for filename, file_id in files:
-            self.contains_one_link(filename, '#' + file_id)
             self.contains_one_anchor(file_id)
+            diffblock = doc.cssselect('[data-f-path="%s"]' % filename)
+            assert len(diffblock) == 1
+            assert len(diffblock[0].cssselect('a[href="#%s"]' % file_id)) == 1
 
     def contains_change_summary(self, files_changed, inserted, deleted):
         template = (

rhodecode/tests/functional/test_files.py

@@ -81,7 +81,7 b' def _commit_change('
     return commit
 
 
-    
+
 @pytest.mark.usefixtures("app")
 class TestFilesController:
 
@@ -270,9 +270,9 b' class TestFilesController:'
             annotate=True))
 
         expected_revisions = {
-            'hg': 'r356:25213a5fbb04',
-            'git': 'r345:c994f0de03b2',
-            'svn': 'r208:209',
+            'hg': 'r356',
+            'git': 'r345',
+            'svn': 'r208',
         }
         response.mustcontain(expected_revisions[backend.alias])
 

rhodecode/tests/functional/test_home.py

@@ -56,7 +56,7 b' class TestHomeController(TestController)'
 
         rhodecode_version_hash = c.rhodecode_version_hash
         response.mustcontain('style.css?ver={0}'.format(rhodecode_version_hash))
-        response.mustcontain('scripts.js?ver={0}'.format(rhodecode_version_hash))
+        response.mustcontain('rhodecode-components.js?ver={0}'.format(rhodecode_version_hash))
 
     def test_index_contains_backend_specific_details(self, backend):
         self.log_user()

rhodecode/tests/functional/test_login.py

@@ -25,7 +25,8 b' import pytest'
 
 from rhodecode.config.routing import ADMIN_PREFIX
 from rhodecode.tests import (
-    assert_session_flash, url, HG_REPO, TEST_USER_ADMIN_LOGIN)
+    TestController, assert_session_flash, clear_all_caches, url,
+    HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import AssertResponse, get_session_from_response
 from rhodecode.lib.auth import check_password, generate_auth_token
@@ -39,6 +40,7 b' fixture = Fixture()'
 
 # Hardcode URLs because we don't have a request object to use
 # pyramids URL generation methods.
+index_url = '/'
 login_url = ADMIN_PREFIX + '/login'
 logut_url = ADMIN_PREFIX + '/logout'
 register_url = ADMIN_PREFIX + '/register'
@@ -517,3 +519,70 b' class TestLoginController:'
                                  repo_name=HG_REPO, revision='tip',
                                  api_key=new_auth_token.api_key),
                              status=302)
+
+
+class TestPasswordReset(TestController):
+
+    @pytest.mark.parametrize(
+        'pwd_reset_setting, show_link, show_reset', [
+            ('hg.password_reset.enabled', True, True),
+            ('hg.password_reset.hidden', False, True),
+            ('hg.password_reset.disabled', False, False),
+        ])
+    def test_password_reset_settings(
+            self, pwd_reset_setting, show_link, show_reset):
+        clear_all_caches()
+        self.log_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
+        params = {
+            'csrf_token': self.csrf_token,
+            'anonymous': 'True',
+            'default_register': 'hg.register.auto_activate',
+            'default_register_message': '',
+            'default_password_reset': pwd_reset_setting,
+            'default_extern_activate': 'hg.extern_activate.auto',
+        }
+        resp = self.app.post(url('admin_permissions_application'), params=params)
+        self.logout_user()
+
+        login_page = self.app.get(login_url)
+        asr_login = AssertResponse(login_page)
+        index_page = self.app.get(index_url)
+        asr_index = AssertResponse(index_page)
+
+        if show_link:
+            asr_login.one_element_exists('a.pwd_reset')
+            asr_index.one_element_exists('a.pwd_reset')
+        else:
+            asr_login.no_element_exists('a.pwd_reset')
+            asr_index.no_element_exists('a.pwd_reset')
+
+        pwdreset_page = self.app.get(pwd_reset_url)
+        
+        asr_reset = AssertResponse(pwdreset_page)
+        if show_reset:
+            assert 'Send password reset email' in pwdreset_page
+            asr_reset.one_element_exists('#email')
+            asr_reset.one_element_exists('#send')
+        else:
+            assert 'Password reset is disabled.' in pwdreset_page
+            asr_reset.no_element_exists('#email')
+            asr_reset.no_element_exists('#send')
+
+    def test_password_form_disabled(self):
+        self.log_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
+        params = {
+            'csrf_token': self.csrf_token,
+            'anonymous': 'True',
+            'default_register': 'hg.register.auto_activate',
+            'default_register_message': '',
+            'default_password_reset': 'hg.password_reset.disabled',
+            'default_extern_activate': 'hg.extern_activate.auto',
+        }
+        self.app.post(url('admin_permissions_application'), params=params)
+        self.logout_user()
+
+        pwdreset_page = self.app.post(
+            pwd_reset_url,
+            {'email': '[e-mail]',}
+        )
+        assert 'Password reset is disabled.' in pwdreset_page

rhodecode/tests/functional/test_pullrequests.py

@@ -30,6 +30,7 b' from rhodecode.model.db import ('
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.user import UserModel
+from rhodecode.model.repo import RepoModel
 from rhodecode.tests import assert_session_flash, url, TEST_USER_ADMIN_LOGIN
 from rhodecode.tests.utils import AssertResponse
 
@@ -187,6 +188,8 b' class TestPullrequestsController:'
             category='error')
 
     def test_update_invalid_source_reference(self, pr_util, csrf_token):
+        from rhodecode.lib.vcs.backends.base import UpdateFailureReason
+
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'branch:invalid-branch:invalid-commit-id'
         Session().add(pull_request)
@@ -201,9 +204,31 b' class TestPullrequestsController:'
             params={'update_commits': 'true', '_method': 'put',
                     'csrf_token': csrf_token})
 
-        assert_session_flash(
-            response, u'Update failed due to missing commits.',
-            category='error')
+        expected_msg = PullRequestModel.UPDATE_STATUS_MESSAGES[
+            UpdateFailureReason.MISSING_SOURCE_REF]
+        assert_session_flash(response, expected_msg, category='error')
+
+    def test_missing_target_reference(self, pr_util, csrf_token):
+        from rhodecode.lib.vcs.backends.base import MergeFailureReason
+        pull_request = pr_util.create_pull_request(
+            approved=True, mergeable=True)
+        pull_request.target_ref = 'branch:invalid-branch:invalid-commit-id'
+        Session().add(pull_request)
+        Session().commit()
+
+        pull_request_id = pull_request.pull_request_id
+        pull_request_url = url(
+            controller='pullrequests', action='show',
+            repo_name=pull_request.target_repo.repo_name,
+            pull_request_id=str(pull_request_id))
+
+        response = self.app.get(pull_request_url)
+
+        assertr = AssertResponse(response)
+        expected_msg = PullRequestModel.MERGE_STATUS_MESSAGES[
+            MergeFailureReason.MISSING_TARGET_REF]
+        assertr.element_contains(
+            'span[data-role="merge-message"]', str(expected_msg))
 
     def test_comment_and_close_pull_request(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request(approved=True)
@@ -256,8 +281,8 b' class TestPullrequestsController:'
     def test_comment_force_close_pull_request(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
-        reviewers_ids = [1, 2]
-        PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)
+        reviewers_data = [(1, ['reason']), (2, ['reason2'])]
+        PullRequestModel().update_reviewers(pull_request_id, reviewers_data)
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
         self.app.post(
@@ -288,28 +313,40 b' class TestPullrequestsController:'
         commits = [
             {'message': 'ancestor'},
             {'message': 'change'},
+            {'message': 'change2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor'])
-        source = backend.create_repo(heads=['change'])
+        source = backend.create_repo(heads=['change2'])
 
         response = self.app.post(
             url(
                 controller='pullrequests',
                 action='create',
-                repo_name=source.repo_name),
-            params={
-                'source_repo': source.repo_name,
-                'source_ref': 'branch:default:' + commit_ids['change'],
-                'target_repo': target.repo_name,
-                'target_ref': 'branch:default:' + commit_ids['ancestor'],
-                'pullrequest_desc': 'Description',
-                'pullrequest_title': 'Title',
-                'review_members': '1',
-                'revisions': commit_ids['change'],
-                'user': '',
-                'csrf_token': csrf_token,
-            },
+                repo_name=source.repo_name
+            ),
+            [
+                ('source_repo', source.repo_name),
+                ('source_ref', 'branch:default:' + commit_ids['change2']),
+                ('target_repo', target.repo_name),
+                ('target_ref',  'branch:default:' + commit_ids['ancestor']),
+                ('pullrequest_desc', 'Description'),
+                ('pullrequest_title', 'Title'),
+                ('__start__', 'review_members:sequence'),
+                    ('__start__', 'reviewer:mapping'),
+                        ('user_id', '1'),
+                        ('__start__', 'reasons:sequence'),
+                            ('reason', 'Some reason'),
+                        ('__end__', 'reasons:sequence'),
+                    ('__end__', 'reviewer:mapping'),
+                ('__end__', 'review_members:sequence'),
+                ('__start__', 'revisions:sequence'),
+                    ('revisions', commit_ids['change']),
+                    ('revisions', commit_ids['change2']),
+                ('__end__', 'revisions:sequence'),
+                ('user', ''),
+                ('csrf_token', csrf_token),
+            ],
             status=302)
 
         location = response.headers['Location']
@@ -317,8 +354,8 b' class TestPullrequestsController:'
         pull_request = PullRequest.get(pull_request_id)
 
         # check that we have now both revisions
-        assert pull_request.revisions == [commit_ids['change']]
-        assert pull_request.source_ref == 'branch:default:' + commit_ids['change']
+        assert pull_request.revisions == [commit_ids['change2'], commit_ids['change']]
+        assert pull_request.source_ref == 'branch:default:' + commit_ids['change2']
         expected_target_ref = 'branch:default:' + commit_ids['ancestor']
         assert pull_request.target_ref == expected_target_ref
 
@@ -344,19 +381,29 b' class TestPullrequestsController:'
             url(
                 controller='pullrequests',
                 action='create',
-                repo_name=source.repo_name),
-            params={
-                'source_repo': source.repo_name,
-                'source_ref': 'branch:default:' + commit_ids['change'],
-                'target_repo': target.repo_name,
-                'target_ref': 'branch:default:' + commit_ids['ancestor-child'],
-                'pullrequest_desc': 'Description',
-                'pullrequest_title': 'Title',
-                'review_members': '2',
-                'revisions': commit_ids['change'],
-                'user': '',
-                'csrf_token': csrf_token,
-            },
+                repo_name=source.repo_name
+            ),
+            [
+                ('source_repo', source.repo_name),
+                ('source_ref', 'branch:default:' + commit_ids['change']),
+                ('target_repo', target.repo_name),
+                ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
+                ('pullrequest_desc', 'Description'),
+                ('pullrequest_title', 'Title'),
+                ('__start__', 'review_members:sequence'),
+                    ('__start__', 'reviewer:mapping'),
+                        ('user_id', '2'),
+                        ('__start__', 'reasons:sequence'),
+                            ('reason', 'Some reason'),
+                        ('__end__', 'reasons:sequence'),
+                    ('__end__', 'reviewer:mapping'),
+                ('__end__', 'review_members:sequence'),
+                ('__start__', 'revisions:sequence'),
+                    ('revisions', commit_ids['change']),
+                ('__end__', 'revisions:sequence'),
+                ('user', ''),
+                ('csrf_token', csrf_token),
+            ],
             status=302)
 
         location = response.headers['Location']
@@ -373,7 +420,8 b' class TestPullrequestsController:'
         assert len(notifications.all()) == 1
 
         # Change reviewers and check that a notification was made
-        PullRequestModel().update_reviewers(pull_request.pull_request_id, [1])
+        PullRequestModel().update_reviewers(
+            pull_request.pull_request_id, [(1, [])])
         assert len(notifications.all()) == 2
 
     def test_create_pull_request_stores_ancestor_commit_id(self, backend,
@@ -397,19 +445,29 b' class TestPullrequestsController:'
             url(
                 controller='pullrequests',
                 action='create',
-                repo_name=source.repo_name),
-            params={
-                'source_repo': source.repo_name,
-                'source_ref': 'branch:default:' + commit_ids['change'],
-                'target_repo': target.repo_name,
-                'target_ref': 'branch:default:' + commit_ids['ancestor-child'],
-                'pullrequest_desc': 'Description',
-                'pullrequest_title': 'Title',
-                'review_members': '1',
-                'revisions': commit_ids['change'],
-                'user': '',
-                'csrf_token': csrf_token,
-            },
+                repo_name=source.repo_name
+            ),
+            [
+                ('source_repo', source.repo_name),
+                ('source_ref', 'branch:default:' + commit_ids['change']),
+                ('target_repo', target.repo_name),
+                ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
+                ('pullrequest_desc', 'Description'),
+                ('pullrequest_title', 'Title'),
+                ('__start__', 'review_members:sequence'),
+                    ('__start__', 'reviewer:mapping'),
+                        ('user_id', '1'),
+                        ('__start__', 'reasons:sequence'),
+                            ('reason', 'Some reason'),
+                        ('__end__', 'reasons:sequence'),
+                    ('__end__', 'reviewer:mapping'),
+                ('__end__', 'review_members:sequence'),
+                ('__start__', 'revisions:sequence'),
+                    ('revisions', commit_ids['change']),
+                ('__end__', 'revisions:sequence'),
+                ('user', ''),
+                ('csrf_token', csrf_token),
+            ],
             status=302)
 
         location = response.headers['Location']
@@ -879,6 +937,97 b' class TestPullrequestsController:'
         response.mustcontain(
             "<script>alert('Hi!')</script>")
 
+    @pytest.mark.parametrize('mergeable', [True, False])
+    def test_shadow_repository_link(
+            self, mergeable, pr_util, http_host_stub):
+        """
+        Check that the pull request summary page displays a link to the shadow
+        repository if the pull request is mergeable. If it is not mergeable
+        the link should not be displayed.
+        """
+        pull_request = pr_util.create_pull_request(
+            mergeable=mergeable, enable_notifications=False)
+        target_repo = pull_request.target_repo.scm_instance()
+        pr_id = pull_request.pull_request_id
+        shadow_url = '{host}/{repo}/pull-request/{pr_id}/repository'.format(
+            host=http_host_stub, repo=target_repo.name, pr_id=pr_id)
+
+        response = self.app.get(url(
+            controller='pullrequests', action='show',
+            repo_name=target_repo.name,
+            pull_request_id=str(pr_id)))
+
+        assertr = AssertResponse(response)
+        if mergeable:
+            assertr.element_value_contains(
+                'div.pr-mergeinfo input', shadow_url)
+            assertr.element_value_contains(
+                'div.pr-mergeinfo input', 'pr-merge')
+        else:
+            assertr.no_element_exists('div.pr-mergeinfo')
+
+
[e-mail]('app')
[e-mail]("git", "hg")
+class TestPullrequestsControllerDelete(object):
+    def test_pull_request_delete_button_permissions_admin(
+            self, autologin_user, user_admin, pr_util):
+        pull_request = pr_util.create_pull_request(
+            author=user_admin.username, enable_notifications=False)
+
+        response = self.app.get(url(
+            controller='pullrequests', action='show',
+            repo_name=pull_request.target_repo.scm_instance().name,
+            pull_request_id=str(pull_request.pull_request_id)))
+
+        response.mustcontain('id="delete_pullrequest"')
+        response.mustcontain('Confirm to delete this pull request')
+
+    def test_pull_request_delete_button_permissions_owner(
+            self, autologin_regular_user, user_regular, pr_util):
+        pull_request = pr_util.create_pull_request(
+            author=user_regular.username, enable_notifications=False)
+
+        response = self.app.get(url(
+            controller='pullrequests', action='show',
+            repo_name=pull_request.target_repo.scm_instance().name,
+            pull_request_id=str(pull_request.pull_request_id)))
+
+        response.mustcontain('id="delete_pullrequest"')
+        response.mustcontain('Confirm to delete this pull request')
+
+    def test_pull_request_delete_button_permissions_forbidden(
+            self, autologin_regular_user, user_regular, user_admin, pr_util):
+        pull_request = pr_util.create_pull_request(
+            author=user_admin.username, enable_notifications=False)
+
+        response = self.app.get(url(
+            controller='pullrequests', action='show',
+            repo_name=pull_request.target_repo.scm_instance().name,
+            pull_request_id=str(pull_request.pull_request_id)))
+        response.mustcontain(no=['id="delete_pullrequest"'])
+        response.mustcontain(no=['Confirm to delete this pull request'])
+
+    def test_pull_request_delete_button_permissions_can_update_cannot_delete(
+            self, autologin_regular_user, user_regular, user_admin, pr_util,
+            user_util):
+
+        pull_request = pr_util.create_pull_request(
+            author=user_admin.username, enable_notifications=False)
+
+        user_util.grant_user_permission_to_repo(
+            pull_request.target_repo, user_regular,
+            'repository.write')
+
+        response = self.app.get(url(
+            controller='pullrequests', action='show',
+            repo_name=pull_request.target_repo.scm_instance().name,
+            pull_request_id=str(pull_request.pull_request_id)))
+
+        response.mustcontain('id="open_edit_pullrequest"')
+        response.mustcontain('id="delete_pullrequest"')
+        response.mustcontain(no=['Confirm to delete this pull request'])
+
 
 def assert_pull_request_status(pull_request, expected_status):
     status = ChangesetStatusModel().calculated_review_status(

rhodecode/tests/integrations/test_slack.py

@@ -19,41 +19,12 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
-import requests
-from mock import Mock, patch
+from mock import patch
 
 from rhodecode import events
 from rhodecode.model.db import Session, Integration
 from rhodecode.integrations.types.slack import SlackIntegrationType
 
[e-mail]
-def repo_push_event(backend, user_regular):
-    commits = [
-        {'message': 'ancestor commit fixes #15'},
-        {'message': 'quick fixes'},
-        {'message': 'change that fixes #41, #2'},
-        {'message': 'this is because 5b23c3532 broke stuff'},
-        {'message': 'last commit'},
-    ]
-    commit_ids = backend.create_master_repo(commits).values()
-    repo = backend.create_repo()
-    scm_extras = {
-        'ip': '127.0.0.1',
-        'username': user_regular.username,
-        'action': '',
-        'repository': repo.repo_name,
-        'scm': repo.scm_instance().alias,
-        'config': '',
-        'server_url': 'http://example.com',
-        'make_lock': None,
-        'locked_by': [None],
-        'commit_ids': commit_ids,
-    }
-
-    return events.RepoPushEvent(repo_name=repo.repo_name,
-                                pushed_commit_ids=commit_ids,
-                                extras=scm_extras)
-
 
 @pytest.fixture
 def slack_settings():

rhodecode/tests/lib/middleware/test_simplesvn.py

@@ -157,7 +157,6 b' class TestSimpleSvnApp(object):'
         expected_headers = [
             ('MS-Author-Via', 'DAV'),
             ('SVN-Supported-Posts', 'create-txn-with-props'),
-            ('X-RhodeCode-Backend', 'svn'),
         ]
         response_headers = self.app._get_response_headers(headers)
         assert sorted(response_headers) == sorted(expected_headers)
@@ -192,7 +191,6 b' class TestSimpleSvnApp(object):'
         expected_response_headers = [
             ('SVN-Supported-Posts', 'create-txn-with-props'),
             ('MS-Author-Via', 'DAV'),
-            ('X-RhodeCode-Backend', 'svn'),
         ]
         request_mock.assert_called_once_with(
             self.environment['REQUEST_METHOD'], expected_url,

rhodecode/tests/lib/middleware/test_simplevcs.py

@@ -28,7 +28,7 b' from rhodecode.lib.caching_query import '
 from rhodecode.lib.hooks_daemon import DummyHooksCallbackDaemon
 from rhodecode.lib.middleware import simplevcs
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
-from rhodecode.lib.middleware.utils import scm_app
+from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.model.db import User, _hash_key
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
@@ -44,13 +44,15 b' class StubVCSController(simplevcs.Simple'
 
     def __init__(self, *args, **kwargs):
         super(StubVCSController, self).__init__(*args, **kwargs)
-        self.repo_name = HG_REPO
+        self._action = 'pull'
+        self._name = HG_REPO
+        self.set_repo_names(None)
 
     def _get_repository_name(self, environ):
-        return HG_REPO
+        return self._name
 
     def _get_action(self, environ):
-        return "pull"
+        return self._action
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         def fake_app(environ, start_response):
@@ -151,7 +153,7 b' def test_provides_traceback_for_appenlig'
 
 def test_provides_utils_scm_app_as_scm_app_by_default(pylonsapp):
     controller = StubVCSController(pylonsapp, pylonsapp.config, None)
-    assert controller.scm_app is scm_app
+    assert controller.scm_app is scm_app_http
 
 
 def test_allows_to_override_scm_app_via_config(pylonsapp):
@@ -171,6 +173,158 b' def test_should_check_locking(query_stri'
     assert result == expected
 
 
+class TestShadowRepoRegularExpression(object):
+    pr_segment = 'pull-request'
+    shadow_segment = 'repository'
+
+    @pytest.mark.parametrize('url, expected', [
+        # repo with/without groups
+        ('My-Repo/{pr_segment}/1/{shadow_segment}', True),
+        ('Group/My-Repo/{pr_segment}/2/{shadow_segment}', True),
+        ('Group/Sub-Group/My-Repo/{pr_segment}/3/{shadow_segment}', True),
+        ('Group/Sub-Group1/Sub-Group2/My-Repo/{pr_segment}/3/{shadow_segment}', True),
+
+        # pull request ID
+        ('MyRepo/{pr_segment}/1/{shadow_segment}', True),
+        ('MyRepo/{pr_segment}/1234567890/{shadow_segment}', True),
+        ('MyRepo/{pr_segment}/-1/{shadow_segment}', False),
+        ('MyRepo/{pr_segment}/invalid/{shadow_segment}', False),
+
+        # unicode
+        (u'Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
+        (u'Sp€çîál-Gröüp/Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
+
+        # trailing/leading slash
+        ('/My-Repo/{pr_segment}/1/{shadow_segment}', False),
+        ('My-Repo/{pr_segment}/1/{shadow_segment}/', False),
+        ('/My-Repo/{pr_segment}/1/{shadow_segment}/', False),
+
+        # misc
+        ('My-Repo/{pr_segment}/1/{shadow_segment}/extra', False),
+        ('My-Repo/{pr_segment}/1/{shadow_segment}extra', False),
+    ])
+    def test_shadow_repo_regular_expression(self, url, expected):
+        from rhodecode.lib.middleware.simplevcs import SimpleVCS
+        url = url.format(
+            pr_segment=self.pr_segment,
+            shadow_segment=self.shadow_segment)
+        match_obj = SimpleVCS.shadow_repo_re.match(url)
+        assert (match_obj is not None) == expected
+
+
[e-mail]('git', 'hg')
+class TestShadowRepoExposure(object):
+
+    def test_pull_on_shadow_repo_propagates_to_wsgi_app(self, pylonsapp):
+        """
+        Check that a pull action to a shadow repo is propagated to the
+        underlying wsgi app.
+        """
+        controller = StubVCSController(pylonsapp, pylonsapp.config, None)
+        controller._check_ssl = mock.Mock()
+        controller.is_shadow_repo = True
+        controller._action = 'pull'
+        controller.stub_response_body = 'dummy body value'
+        environ_stub = {
+            'HTTP_HOST': 'test.example.com',
+            'REQUEST_METHOD': 'GET',
+            'wsgi.url_scheme': 'http',
+        }
+
+        response = controller(environ_stub, mock.Mock())
+        response_body = ''.join(response)
+
+        # Assert that we got the response from the wsgi app.
+        assert response_body == controller.stub_response_body
+
+    def test_push_on_shadow_repo_raises(self, pylonsapp):
+        """
+        Check that a push action to a shadow repo is aborted.
+        """
+        controller = StubVCSController(pylonsapp, pylonsapp.config, None)
+        controller._check_ssl = mock.Mock()
+        controller.is_shadow_repo = True
+        controller._action = 'push'
+        controller.stub_response_body = 'dummy body value'
+        environ_stub = {
+            'HTTP_HOST': 'test.example.com',
+            'REQUEST_METHOD': 'GET',
+            'wsgi.url_scheme': 'http',
+        }
+
+        response = controller(environ_stub, mock.Mock())
+        response_body = ''.join(response)
+
+        assert response_body != controller.stub_response_body
+        # Assert that a 406 error is returned.
+        assert '406 Not Acceptable' in response_body
+
+    def test_set_repo_names_no_shadow(self, pylonsapp):
+        """
+        Check that the set_repo_names method sets all names to the one returned
+        by the _get_repository_name method on a request to a non shadow repo.
+        """
+        environ_stub = {}
+        controller = StubVCSController(pylonsapp, pylonsapp.config, None)
+        controller._name = 'RepoGroup/MyRepo'
+        controller.set_repo_names(environ_stub)
+        assert not controller.is_shadow_repo
+        assert (controller.url_repo_name ==
+                controller.acl_repo_name ==
+                controller.vcs_repo_name ==
+                controller._get_repository_name(environ_stub))
+
+    def test_set_repo_names_with_shadow(self, pylonsapp, pr_util):
+        """
+        Check that the set_repo_names method sets correct names on a request
+        to a shadow repo.
+        """
+        from rhodecode.model.pull_request import PullRequestModel
+
+        pull_request = pr_util.create_pull_request()
+        shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
+            target=pull_request.target_repo.repo_name,
+            pr_id=pull_request.pull_request_id,
+            pr_segment=TestShadowRepoRegularExpression.pr_segment,
+            shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
+        controller = StubVCSController(pylonsapp, pylonsapp.config, None)
+        controller._name = shadow_url
+        controller.set_repo_names({})
+
+        # Get file system path to shadow repo for assertions.
+        workspace_id = PullRequestModel()._workspace_id(pull_request)
+        target_vcs = pull_request.target_repo.scm_instance()
+        vcs_repo_name = target_vcs._get_shadow_repository_path(
+            workspace_id)
+
+        assert controller.vcs_repo_name == vcs_repo_name
+        assert controller.url_repo_name == shadow_url
+        assert controller.acl_repo_name == pull_request.target_repo.repo_name
+        assert controller.is_shadow_repo
+
+    def test_set_repo_names_with_shadow_but_missing_pr(
+            self, pylonsapp, pr_util):
+        """
+        Checks that the set_repo_names method enforces matching target repos
+        and pull request IDs.
+        """
+        pull_request = pr_util.create_pull_request()
+        shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
+            target=pull_request.target_repo.repo_name,
+            pr_id=999999999,
+            pr_segment=TestShadowRepoRegularExpression.pr_segment,
+            shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
+        controller = StubVCSController(pylonsapp, pylonsapp.config, None)
+        controller._name = shadow_url
+        controller.set_repo_names({})
+
+        assert not controller.is_shadow_repo
+        assert (controller.url_repo_name ==
+                controller.acl_repo_name ==
+                controller.vcs_repo_name)
+
+
[e-mail]('db')
 @mock.patch.multiple(
     'Pyro4.config', SERVERTYPE='multiplex', POLLTIMEOUT=0.01)
 class TestGenerateVcsResponse:
@@ -245,7 +399,6 b' class TestGenerateVcsResponse:'
         result = controller._generate_vcs_response(
             environ={}, start_response=self.start_response,
             repo_path='fake_repo_path',
-            repo_name='fake_repo_name',
             extras={}, action='push')
         self.controller = controller
         return result

rhodecode/tests/lib/middleware/test_vcs_unavailable.py

@@ -20,8 +20,7 b''
 
 import mock
 import pytest
-import rhodecode
-import rhodecode.lib.vcs.client as client
+
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 def test_vcs_available_returns_summary_page(app, backend):
@@ -32,16 +31,31 b' def test_vcs_available_returns_summary_p'
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
-def test_vcs_unavailable_returns_vcs_error_page(app, backend):
+def test_vcs_unavailable_returns_vcs_error_page(app, backend, app_settings):
+    from rhodecode.lib.vcs.exceptions import VCSCommunicationError
+    from rhodecode.lib.middleware.error_handling import (
+        PylonsErrorHandlingMiddleware)
+
+    # Depending on the used VCSServer protocol we have to patch a different
+    # RemoteRepo class to raise an exception. For the test it doesn't matter
+    # if http or pyro4 is used, it just requires the exception to be raised.
+    vcs_protocol = app_settings['vcs.server.protocol']
+    if vcs_protocol == 'http':
+        from rhodecode.lib.vcs.client_http import RemoteRepo
+    elif vcs_protocol == 'pyro4':
+        from rhodecode.lib.vcs.client import RemoteRepo
+    else:
+        pytest.fail('Unknown VCS server protocol: "{}"'.format(vcs_protocol))
+
     url = '/{repo_name}'.format(repo_name=backend.repo.repo_name)
 
-    try:
-        rhodecode.disable_error_handler = False
-        with mock.patch.object(client, '_get_proxy_method') as p:
-            p.side_effect = client.exceptions.PyroVCSCommunicationError()
+    # Patch remote repo to raise an exception instead of making a RPC.
+    with mock.patch.object(RemoteRepo, '__getattr__') as remote_mock:
+        remote_mock.side_effect = VCSCommunicationError()
+        # Patch pylons error handling middleware to not re-raise exceptions.
+        with mock.patch.object(PylonsErrorHandlingMiddleware, 'reraise') as r:
+            r.return_value = False
             response = app.get(url, expect_errors=True)
-    finally:
-        rhodecode.disable_error_handler = True
 
     assert response.status_code == 502
     assert 'Could not connect to VCS Server' in response.body

rhodecode/tests/lib/middleware/utils/test_scm_app_http.py

@@ -33,7 +33,7 b' def vcs_http_app(vcsserver_http_echo_app'
     """
     git_url = vcsserver_http_echo_app.http_url + 'stream/git/'
     vcs_http_proxy = scm_app_http.VcsHttpProxy(
-        git_url, 'stub_path', 'stub_name', None, 'stub_backend')
+        git_url, 'stub_path', 'stub_name', None)
     app = webtest.TestApp(vcs_http_proxy)
     return app
 

rhodecode/tests/lib/middleware/utils/test_scm_app_http_chunking.py

@@ -24,7 +24,7 b' Checking the chunked data transfer via H'
 
 import os
 import time
-import subprocess
+import subprocess32
 
 import pytest
 import requests
@@ -53,7 +53,7 b' def echo_app_chunking(request, available'
         'rhodecode.tests.lib.middleware.utils.test_scm_app_http_chunking'
         ':create_echo_app')
     command = command.format(port=port)
-    proc = subprocess.Popen(command.split(' '), bufsize=0)
+    proc = subprocess32.Popen(command.split(' '), bufsize=0)
     echo_app_url = 'http://localhost:' + str(port)
 
     @request.addfinalizer
@@ -78,7 +78,7 b' def scm_app(request, available_port_fact'
     command = command.format(port=port)
     env = os.environ.copy()
     env["RC_ECHO_URL"] = echo_app_chunking
-    proc = subprocess.Popen(command.split(' '), bufsize=0, env=env)
+    proc = subprocess32.Popen(command.split(' '), bufsize=0, env=env)
     scm_app_url = 'http://localhost:' + str(port)
     wait_for_url(scm_app_url)
 
@@ -133,4 +133,4 b' def create_scm_app():'
     """
     echo_app_url = os.environ["RC_ECHO_URL"]
     return scm_app_http.VcsHttpProxy(
-        echo_app_url, 'stub_path', 'stub_name', None, 'stub_backend')
+        echo_app_url, 'stub_path', 'stub_name', None)

rhodecode/tests/lib/middleware/utils/test_wsgi_app_caller_client.py

@@ -93,6 +93,8 b' def test_remote_app_caller():'
     response = test_app.get('/path')
 
     assert response.status == '200 OK'
-    assert response.headers.items() == [
-        ('Content-Type', 'text/plain'), ('Content-Length', '7')]
+    assert sorted(response.headers.items()) == sorted([
+        ('Content-Type', 'text/plain'),
+        ('Content-Length', '7'),
+    ])
     assert response.body == 'content'

rhodecode/tests/lib/test_diffs.py

@@ -76,7 +76,7 b' def test_diffprocessor_as_html_with_comm'
     expected_html = textwrap.dedent('''
         <table class="code-difftable">
         <tr class="line context">
-            <td class="add-comment-line"><span class="add-comment-content"></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td  class="lineno old">...</td>
             <td  class="lineno new">...</td>
             <td class="code no-comment">
@@ -85,7 +85,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o2" class="lineno old"><a href="#setuppy_o2" class="tooltip"
                         title="Click to select line">2</a></td>
             <td id="setuppy_n2" class="lineno new"><a href="#setuppy_n2" class="tooltip"
@@ -96,7 +96,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o3" class="lineno old"><a href="#setuppy_o3" class="tooltip"
                         title="Click to select line">3</a></td>
             <td id="setuppy_n3" class="lineno new"><a href="#setuppy_n3" class="tooltip"
@@ -107,7 +107,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o4" class="lineno old"><a href="#setuppy_o4" class="tooltip"
                         title="Click to select line">4</a></td>
             <td id="setuppy_n4" class="lineno new"><a href="#setuppy_n4" class="tooltip"
@@ -118,7 +118,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line del">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o5" class="lineno old"><a href="#setuppy_o5" class="tooltip"
                         title="Click to select line">5</a></td>
             <td  class="lineno new"><a href="#setuppy_n" class="tooltip"
@@ -129,7 +129,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line add">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td  class="lineno old"><a href="#setuppy_o" class="tooltip"
                         title="Click to select line"></a></td>
             <td id="setuppy_n5" class="lineno new"><a href="#setuppy_n5" class="tooltip"
@@ -140,7 +140,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o6" class="lineno old"><a href="#setuppy_o6" class="tooltip"
                         title="Click to select line">6</a></td>
             <td id="setuppy_n6" class="lineno new"><a href="#setuppy_n6" class="tooltip"
@@ -151,7 +151,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o7" class="lineno old"><a href="#setuppy_o7" class="tooltip"
                         title="Click to select line">7</a></td>
             <td id="setuppy_n7" class="lineno new"><a href="#setuppy_n7" class="tooltip"
@@ -162,7 +162,7 b' def test_diffprocessor_as_html_with_comm'
             </td>
         </tr>
         <tr class="line unmod">
-            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comments"><i class="icon-comment"></i></td>
+            <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o8" class="lineno old"><a href="#setuppy_o8" class="tooltip"
                         title="Click to select line">8</a></td>
             <td id="setuppy_n8" class="lineno new"><a href="#setuppy_n8" class="tooltip"

rhodecode/tests/lib/test_hooks_base.py

@@ -19,6 +19,7 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
+import pytest
 
 from rhodecode.lib import hooks_base, utils2
 
@@ -40,6 +41,7 b' def test_post_push_truncates_commits(use'
         'make_lock': None,
         'locked_by': [None],
         'commit_ids': ['abcde12345' * 4] * 30000,
+        'is_shadow_repo': False,
     }
     extras = utils2.AttributeDict(extras)
 
@@ -51,3 +53,90 b' def test_post_push_truncates_commits(use'
     hooks_base.action_logger.assert_called_with(
         extras.username, expected_action, extras.repository, extras.ip,
         commit=True)
+
+
+def assert_called_with_mock(callable_, expected_mock_name):
+    mock_obj = callable_.call_args[0][0]
+    mock_name = mock_obj._mock_new_parent._mock_new_name
+    assert mock_name == expected_mock_name
+
+
[e-mail]
+def hook_extras(user_regular, repo_stub):
+    extras = utils2.AttributeDict({
+        'ip': '127.0.0.1',
+        'username': user_regular.username,
+        'action': 'push',
+        'repository': repo_stub.repo_name,
+        'scm': '',
+        'config': '',
+        'server_url': 'http://example.com',
+        'make_lock': None,
+        'locked_by': [None],
+        'commit_ids': [],
+        'is_shadow_repo': False,
+    })
+    return extras
+
+
[e-mail]('func, extension, event', [
+    (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
+    (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
+    (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
+    (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
+])
+def test_hooks_propagate(func, extension, event, hook_extras):
+    """
+    Tests that our hook code propagates to rhodecode extensions and triggers
+    the appropriate event.
+    """
+    extension_mock = mock.Mock()
+    events_mock = mock.Mock()
+    patches = {
+        'Repository': mock.Mock(),
+        'events': events_mock,
+        extension: extension_mock,
+    }
+
+    # Clear shadow repo flag.
+    hook_extras.is_shadow_repo = False
+
+    # Execute hook function.
+    with mock.patch.multiple(hooks_base, **patches):
+        func(hook_extras)
+
+    # Assert that extensions are called and event was fired.
+    extension_mock.called_once()
+    assert_called_with_mock(events_mock.trigger, event)
+
+
[e-mail]('func, extension, event', [
+    (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
+    (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
+    (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
+    (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
+])
+def test_hooks_propagates_not_on_shadow(func, extension, event, hook_extras):
+    """
+    If hooks are called by a request to a shadow repo we only want to run our
+    internal hooks code but not external ones like rhodecode extensions or
+    trigger an event.
+    """
+    extension_mock = mock.Mock()
+    events_mock = mock.Mock()
+    patches = {
+        'Repository': mock.Mock(),
+        'events': events_mock,
+        extension: extension_mock,
+    }
+
+    # Set shadow repo flag.
+    hook_extras.is_shadow_repo = True
+
+    # Execute hook function.
+    with mock.patch.multiple(hooks_base, **patches):
+        func(hook_extras)
+
+    # Assert that extensions are *not* called and event was *not* fired.
+    assert not extension_mock.called
+    assert not events_mock.trigger.called

rhodecode/tests/lib/test_hooks_daemon.py

@@ -318,18 +318,18 b' class TestHttpHooksCallbackDaemon(object'
 
 
 class TestPrepareHooksDaemon(object):
-    def test_returns_dummy_hooks_callback_daemon_when_using_direct_calls(self):
+    @pytest.mark.parametrize('protocol', ('http', 'pyro4'))
+    def test_returns_dummy_hooks_callback_daemon_when_using_direct_calls(
+            self, protocol):
         expected_extras = {'extra1': 'value1'}
         callback, extras = hooks_daemon.prepare_callback_daemon(
-            expected_extras.copy(), use_direct_calls=True)
+            expected_extras.copy(), protocol=protocol, use_direct_calls=True)
         assert isinstance(callback, hooks_daemon.DummyHooksCallbackDaemon)
         expected_extras['hooks_module'] = 'rhodecode.lib.hooks_daemon'
         assert extras == expected_extras
 
     @pytest.mark.parametrize('protocol, expected_class', (
         ('pyro4', hooks_daemon.Pyro4HooksCallbackDaemon),
-        ('Pyro4', hooks_daemon.Pyro4HooksCallbackDaemon),
-        ('HTTP', hooks_daemon.HttpHooksCallbackDaemon),
         ('http', hooks_daemon.HttpHooksCallbackDaemon)
     ))
     def test_returns_real_hooks_callback_daemon_when_protocol_is_specified(
@@ -339,13 +339,30 b' class TestPrepareHooksDaemon(object):'
             'hooks_protocol': protocol.lower()
         }
         callback, extras = hooks_daemon.prepare_callback_daemon(
-            expected_extras.copy(), protocol=protocol)
+            expected_extras.copy(), protocol=protocol, use_direct_calls=False)
         assert isinstance(callback, expected_class)
         hooks_uri = extras.pop('hooks_uri')
         assert extras == expected_extras
         if protocol.lower() == 'pyro4':
             assert hooks_uri.startswith('PYRO')
 
+    @pytest.mark.parametrize('protocol', (
+        'invalid',
+        'Pyro4',
+        'Http',
+        'HTTP',
+    ))
+    def test_raises_on_invalid_protocol(self, protocol):
+        expected_extras = {
+            'extra1': 'value1',
+            'hooks_protocol': protocol.lower()
+        }
+        with pytest.raises(Exception):
+            callback, extras = hooks_daemon.prepare_callback_daemon(
+                expected_extras.copy(),
+                protocol=protocol,
+                use_direct_calls=False)
+
 
 class MockRequest(object):
     def __init__(self, request):

rhodecode/tests/lib/test_jsonalchemy.py

@@ -21,7 +21,22 b''
 import pickle
 import pytest
 
-from rhodecode.lib.jsonalchemy import MutationDict, MutationList
+from sqlalchemy import Column, String, create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+from rhodecode.lib.jsonalchemy import (
+    MutationDict, MutationList, MutationObj, JsonType)
+
+
[e-mail]
+def engine():
+    return create_engine('sqlite://')
+
+
[e-mail]
+def session(engine):
+    return sessionmaker(bind=engine)()
 
 
 def test_mutation_dict_is_picklable():
@@ -30,12 +45,14 b' def test_mutation_dict_is_picklable():'
     loaded = pickle.loads(dumped)
     assert loaded == mutation_dict
 
+
 def test_mutation_list_is_picklable():
     mutation_list = MutationList(['a', 'b', 'c'])
     dumped = pickle.dumps(mutation_list)
     loaded = pickle.loads(dumped)
     assert loaded == mutation_list
 
+
 def test_mutation_dict_with_lists_is_picklable():
     mutation_dict = MutationDict({
         'key': MutationList(['values', MutationDict({'key': 'value'})])
@@ -43,3 +60,48 b' def test_mutation_dict_with_lists_is_pic'
     dumped = pickle.dumps(mutation_dict)
     loaded = pickle.loads(dumped)
     assert loaded == mutation_dict
+
+
+def test_mutation_types_with_nullable(engine, session):
+    # TODO: dan: ideally want to make this parametrized python => sql tests eg:
+    # (MutationObj, 5) => '5'
+    # (MutationObj, {'a': 5}) => '{"a": 5}'
+    # (MutationObj, None) => 'null' <- think about if None is 'null' or NULL
+
+    Base = declarative_base()
+
+    class DummyModel(Base):
+        __tablename__ = 'some_table'
+        name = Column(String, primary_key=True)
+        json_list = Column(MutationList.as_mutable(JsonType('list')))
+        json_dict = Column(MutationDict.as_mutable(JsonType('dict')))
+        json_obj = Column(MutationObj.as_mutable(JsonType()))
+
+    Base.metadata.create_all(engine)
+
+    obj_nulls = DummyModel(name='nulls')
+    obj_stuff = DummyModel(
+        name='stuff', json_list=[1,2,3], json_dict={'a': 5}, json_obj=9)
+
+    session.add(obj_nulls)
+    session.add(obj_stuff)
+    session.commit()
+    session.expire_all()
+
+    assert engine.execute(
+        "select * from some_table where name = 'nulls';").first() == (
+        (u'nulls', None, None, None)
+    )
+    ret_nulls = session.query(DummyModel).get('nulls')
+    assert ret_nulls.json_list == []
+    assert ret_nulls.json_dict == {}
+    assert ret_nulls.json_obj is None
+
+    assert engine.execute(
+        "select * from some_table where name = 'stuff';").first() == (
+        (u'stuff', u'[1, 2, 3]', u'{"a": 5}', u'9')
+    )
+    ret_stuff = session.query(DummyModel).get('stuff')
+    assert ret_stuff.json_list == [1, 2, 3]
+    assert ret_stuff.json_dict == {'a': 5}
+    assert ret_stuff.json_obj == 9

rhodecode/tests/load/http_performance.py

@@ -32,7 +32,7 b' import itertools'
 import os
 import pprint
 import shutil
-import subprocess
+import subprocess32
 import sys
 import time
 
@@ -77,12 +77,12 b' def execute(*popenargs, **kwargs):'
     input = kwargs.pop('stdin', None)
     stdin = None
     if input:
-        stdin = subprocess.PIPE
+        stdin = subprocess32.PIPE
     #if 'stderr' not in kwargs:
-    #    kwargs['stderr'] = subprocess.PIPE
+    #    kwargs['stderr'] = subprocess32.PIPE
     if 'stdout' in kwargs:
         raise ValueError('stdout argument not allowed, it will be overridden.')
-    process = subprocess.Popen(stdin=stdin, stdout=subprocess.PIPE,
+    process = subprocess32.Popen(stdin=stdin, stdout=subprocess32.PIPE,
                                *popenargs, **kwargs)
     output, error = process.communicate(input=input)
     retcode = process.poll()
@@ -91,7 +91,7 b' def execute(*popenargs, **kwargs):'
         if cmd is None:
             cmd = popenargs[0]
         print cmd, output, error
-        raise subprocess.CalledProcessError(retcode, cmd, output=output)
+        raise subprocess32.CalledProcessError(retcode, cmd, output=output)
     return output
 
 

rhodecode/tests/load/profile.py

@@ -31,7 +31,7 b' To stop the script by press Ctrl-C'
 import datetime
 import os
 import psutil
-import subprocess
+import subprocess32
 import sys
 import time
 import traceback
@@ -66,7 +66,7 b' def dump_system():'
 
 
 def count_dulwich_fds(proc):
-    p = subprocess.Popen(["lsof", "-p", proc.pid], stdout=subprocess.PIPE)
+    p = subprocess32.Popen(["lsof", "-p", proc.pid], stdout=subprocess32.PIPE)
     out, err = p.communicate()
 
     count = 0
@@ -117,7 +117,7 b' print "VCS - Ok"'
 
 print "\nStarting RhodeCode..."
 rc = psutil.Popen("RC_VCSSERVER_TEST_DISABLE=1 paster serve test.ini",
-                  shell=True, stdin=subprocess.PIPE)
+                  shell=True, stdin=subprocess32.PIPE)
 time.sleep(1)
 if not rc.is_running():
     print "RC - Failed to start"

rhodecode/tests/load/vcs_performance.py

@@ -40,7 +40,7 b' import functools'
 import logging
 import os
 import shutil
-import subprocess
+import subprocess32
 import tempfile
 import time
 from itertools import chain
@@ -145,8 +145,8 b' class Repository(object):'
 
     def _run(self, *args):
         command = [self.BASE_COMMAND] + list(args)
-        process = subprocess.Popen(
-            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        process = subprocess32.Popen(
+            command, stdout=subprocess32.PIPE, stderr=subprocess32.PIPE)
         return process.communicate()
 
     def _create_file(self, name, size):

rhodecode/tests/models/schemas/test_integration_schema.py

@@ -21,8 +21,6 b''
 import colander
 import pytest
 
-from rhodecode.model import validation_schema
-
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.model.validation_schema.schemas.integration_schema import (
@@ -33,14 +31,12 b' from rhodecode.model.validation_schema.s'
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationSchema(object):
 
-    def test_deserialize_integration_schema_perms(self, backend_random,
-                                                  test_repo_group,
-                                                  StubIntegrationType):
+    def test_deserialize_integration_schema_perms(
+            self, backend_random, test_repo_group, StubIntegrationType):
 
         repo = backend_random.repo
         repo_group = test_repo_group
 
-
         empty_perms_dict = {
             'global': [],
             'repositories': {},

rhodecode/tests/models/schemas/test_schema_types.py

@@ -21,26 +21,82 b''
 import colander
 import pytest
 
-from rhodecode.model.validation_schema.types import GroupNameType
+from rhodecode.model.validation_schema.types import (
+    GroupNameType, RepoNameType, StringBooleanType)
 
 
 class TestGroupNameType(object):
     @pytest.mark.parametrize('given, expected', [
         ('//group1/group2//', 'group1/group2'),
         ('//group1///group2//', 'group1/group2'),
-        ('group1/group2///group3', 'group1/group2/group3')
+        ('group1/group2///group3', 'group1/group2/group3'),
     ])
-    def test_replace_extra_slashes_cleans_up_extra_slashes(
-            self, given, expected):
-        type_ = GroupNameType()
-        result = type_._replace_extra_slashes(given)
+    def test_normalize_path(self, given, expected):
+        result = GroupNameType()._normalize(given)
         assert result == expected
 
-    def test_deserialize_cleans_up_extra_slashes(self):
+    @pytest.mark.parametrize('given, expected', [
+        ('//group1/group2//', 'group1/group2'),
+        ('//group1///group2//', 'group1/group2'),
+        ('group1/group2///group3', 'group1/group2/group3'),
+        ('v1.2', 'v1.2'),
+        ('/v1.2', 'v1.2'),
+        ('.dirs', '.dirs'),
+        ('..dirs', '.dirs'),
+        ('./..dirs', '.dirs'),
+        ('dir/;name;/;[];/sub', 'dir/name/sub'),
+        (',/,/,d,,,', 'd'),
+        ('/;/#/,d,,,', 'd'),
+        ('long../../..name', 'long./.name'),
+        ('long../..name', 'long./.name'),
+        ('../', ''),
+        ('\'../"../', ''),
+        ('c,/,/..//./,c,,,/.d/../.........c', 'c/c/.d/.c'),
+        ('c,/,/..//./,c,,,', 'c/c'),
+        ('d../..d', 'd./.d'),
+        ('d../../d', 'd./d'),
+
+        ('d\;\./\,\./d', 'd./d'),
+        ('d\.\./\.\./d', 'd./d'),
+        ('d\.\./\..\../d', 'd./d'),
+    ])
+    def test_deserialize_clean_up_name(self, given, expected):
         class TestSchema(colander.Schema):
-            field = colander.SchemaNode(GroupNameType())
+            field_group = colander.SchemaNode(GroupNameType())
+            field_repo = colander.SchemaNode(RepoNameType())
 
         schema = TestSchema()
-        cleaned_data = schema.deserialize(
-            {'field': '//group1/group2///group3//'})
-        assert cleaned_data['field'] == 'group1/group2/group3'
+        cleaned_data = schema.deserialize({
+            'field_group': given,
+            'field_repo': given
+        })
+        assert cleaned_data['field_group'] == expected
+        assert cleaned_data['field_repo'] == expected
+
+
+class TestStringBooleanType(object):
+
+    def _get_schema(self):
+        class Schema(colander.MappingSchema):
+            bools = colander.SchemaNode(StringBooleanType())
+        return Schema()
+
+    @pytest.mark.parametrize('given, expected', [
+        ('1', True),
+        ('yEs', True),
+        ('true', True),
+
+        ('0', False),
+        ('NO', False),
+        ('FALSE', False),
+
+    ])
+    def test_convert_type(self, given, expected):
+        schema = self._get_schema()
+        result = schema.deserialize({'bools':given})
+        assert result['bools'] == expected
+
+    def test_try_convert_bad_type(self):
+        schema = self._get_schema()
+        with pytest.raises(colander.Invalid):
+            result = schema.deserialize({'bools': 'boom'})

rhodecode/tests/models/test_permissions.py

@@ -348,6 +348,7 b' class TestPermissions(object):'
             'hg.create.none',
             'hg.fork.none',
             'hg.register.manual_activate',
+            'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',
@@ -379,6 +380,7 b' class TestPermissions(object):'
             'hg.create.repository',
             'hg.fork.repository',
             'hg.register.manual_activate',
+            'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',
@@ -406,6 +408,7 b' class TestPermissions(object):'
             'hg.create.none',
             'hg.fork.none',
             'hg.register.manual_activate',
+            'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',

rhodecode/tests/models/test_pullrequest.py

@@ -25,7 +25,8 b' import textwrap'
 import rhodecode
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends import get_backend
-from rhodecode.lib.vcs.backends.base import MergeResponse, MergeFailureReason
+from rhodecode.lib.vcs.backends.base import (
+    MergeResponse, MergeFailureReason, Reference)
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.model.comment import ChangesetCommentsModel
@@ -115,7 +116,7 b' class TestPullRequestModel:'
 
     def test_get_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
-            pull_request, [pull_request.author])
+            pull_request, [(pull_request.author, ['author'])])
         prs = PullRequestModel().get_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert isinstance(prs, list)
@@ -123,7 +124,7 b' class TestPullRequestModel:'
 
     def test_count_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
-            pull_request, [pull_request.author])
+            pull_request, [(pull_request.author, ['author'])])
         pr_count = PullRequestModel().count_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert pr_count == 1
@@ -269,10 +270,10 b' class TestPullRequestModel:'
 
     def test_merge(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
+        merge_ref = Reference(
+            'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
-            True, True,
-            '6126b7bfcc82ad2d3deaee22af926b082ce54cc6',
-            MergeFailureReason.NONE)
+            True, True, merge_ref, MergeFailureReason.NONE)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge(
@@ -308,10 +309,10 b' class TestPullRequestModel:'
 
     def test_merge_failed(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
+        merge_ref = Reference(
+            'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
-            False, False,
-            '6126b7bfcc82ad2d3deaee22af926b082ce54cc6',
-            MergeFailureReason.MERGE_FAILED)
+            False, False, merge_ref, MergeFailureReason.MERGE_FAILED)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge(
@@ -359,6 +360,14 b' class TestPullRequestModel:'
             pull_request, context=6)
         assert 'file_1' in diff.raw
 
+    def test_generate_title_returns_unicode(self):
+        title = PullRequestModel().generate_pullrequest_title(
+            source='source-dummy',
+            source_ref='source-ref-dummy',
+            target='target-dummy',
+        )
+        assert type(title) == unicode
+
 
 class TestIntegrationMerge(object):
     @pytest.mark.parametrize('extra_config', (
@@ -449,6 +458,7 b' def merge_extras(user_regular):'
         'locked_by': [None, None, None],
         'server_url': 'http://test.example.com:5000',
         'hooks': ['push', 'pull'],
+        'is_shadow_repo': False,
     }
     return extras
 

rhodecode/tests/models/test_user_groups.py

@@ -113,40 +113,20 b' def test_add_and_remove_user_from_group('
     assert user_group.members == []
 
 
[e-mail](
-    'data, expected', [
-        ("1", [1]), (["1", "2"], [1, 2])
-    ]
-)
[e-mail]('data, expected', [
+    ([], []),
+    ([{"member_user_id": 1, "type": "new"}], [1]),
+    ([{"member_user_id": 1, "type": "new"},
+      {"member_user_id": 1, "type": "existing"}], [1]),
+    ([{"member_user_id": 1, "type": "new"},
+      {"member_user_id": 2, "type": "new"},
+      {"member_user_id": 3, "type": "remove"}], [1, 2])
+])
 def test_clean_members_data(data, expected):
     cleaned = UserGroupModel()._clean_members_data(data)
     assert cleaned == expected
 
 
-def test_update_members_from_user_ids(user_regular, user_util):
-    user_group = user_util.create_user_group()
-    assert user_group.members == []
-    assert user_group.user != user_regular
-    expected_active_state = not user_group.users_group_active
-
-    form_data = {
-        'users_group_members': str(user_regular.user_id),
-        'user': str(user_regular.username),
-        'users_group_name': 'changed_name',
-        'users_group_active': expected_active_state,
-        'user_group_description': 'changed_description'
-    }
-
-    UserGroupModel().update(user_group, form_data)
-    assert user_group.members[0].user_id == user_regular.user_id
-    assert user_group.user_id == user_regular.user_id
-    assert 'changed_name' in user_group.users_group_name
-    assert 'changed_description' in user_group.user_group_description
-    assert user_group.users_group_active == expected_active_state
-    # Ignore changes on the test
-    Session().rollback()
-
-
 def _create_test_members():
     members = []
     for member_number in range(3):

rhodecode/tests/other/vcs_operations/__init__.py

@@ -28,7 +28,7 b' Base for test suite for making push/pull'
 """
 
 from os.path import join as jn
-from subprocess import Popen, PIPE
+from subprocess32 import Popen, PIPE
 import logging
 import os
 import tempfile

rhodecode/tests/other/vcs_operations/conftest.py

@@ -29,7 +29,7 b' py.test config for test suite for making'
 
 import ConfigParser
 import os
-import subprocess
+import subprocess32
 import tempfile
 import textwrap
 import pytest
@@ -164,7 +164,7 b' def rc_web_server('
     print('Command: {}'.format(command))
     print('Logfile: {}'.format(RC_LOG))
 
-    proc = subprocess.Popen(
+    proc = subprocess32.Popen(
         command, bufsize=0, env=env, stdout=server_out, stderr=server_out)
 
     wait_for_url(host_url, timeout=30)

rhodecode/tests/plugin.py

@@ -26,7 +26,7 b' import re'
 import pprint
 import shutil
 import socket
-import subprocess
+import subprocess32
 import time
 import uuid
 
@@ -38,11 +38,12 b' import requests'
 from webtest.app import TestApp
 
 import rhodecode
+from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
-    UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi, Integration)
+    UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
@@ -218,7 +219,7 b' def app(request, pylonsapp, http_environ'
     return app
 
 
[e-mail]()
[e-mail](scope='session')
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
@@ -234,6 +235,18 b' def app_settings(pylonsapp, pylons_confi'
     return settings
 
 
[e-mail](scope='session')
+def db(app_settings):
+    """
+    Initializes the database connection.
+
+    It uses the same settings which are used to create the ``pylonsapp`` or
+    ``app`` fixtures.
+    """
+    from rhodecode.config.utils import initialize_database
+    initialize_database(app_settings)
+
+
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
@@ -872,7 +885,7 b' class RepoServer(object):'
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
-        proc = subprocess.Popen(
+        proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
@@ -1120,7 +1133,7 b' def user_util(request, pylonsapp):'
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
-        self._test_name = test_name
+        self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.user_ids = []
@@ -1133,6 +1146,11 b' class UserUtility(object):'
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
+    def _sanitize_name(self, name):
+        for char in ['[', ']']:
+            name = name.replace(char, '_')
+        return name
+
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(

rhodecode/tests/pylons_plugin.py

@@ -23,7 +23,7 b' import logging.config'
 import os
 import platform
 import socket
-import subprocess
+import subprocess32
 import time
 from urllib2 import urlopen, URLError
 
@@ -48,6 +48,9 b' def _parse_json(value):'
 
 
 def pytest_addoption(parser):
+    parser.addoption(
+        '--test-loglevel', dest='test_loglevel',
+        help="Set default Logging level for tests, warn (default), info, debug")
     group = parser.getgroup('pylons')
     group.addoption(
         '--with-pylons', dest='pylons_config',
@@ -68,7 +71,7 b' def pytest_addoption(parser):'
         '--without-vcsserver', dest='with_vcsserver', action='store_false',
         help="Do not start the VCSServer in a background process.")
     vcsgroup.addoption(
-        '--with-vcsserver', dest='vcsserver_config',
+        '--with-vcsserver', dest='vcsserver_config_pyro4',
         help="Start the VCSServer with the specified config file.")
     vcsgroup.addoption(
         '--with-vcsserver-http', dest='vcsserver_config_http',
@@ -91,7 +94,7 b' def pytest_addoption(parser):'
             "against an already running server and random ports cause "
             "trouble."))
     parser.addini(
-        'vcsserver_config',
+        'vcsserver_config_pyro4',
         "Start the VCSServer with the specified config file.")
     parser.addini(
         'vcsserver_config_http',
@@ -134,7 +137,7 b' def vcsserver_factory(tmpdir_factory):'
     Use this if you need a running vcsserver with a special configuration.
     """
 
-    def factory(request, use_http=False, overrides=(), vcsserver_port=None):
+    def factory(request, use_http=True, overrides=(), vcsserver_port=None):
 
         if vcsserver_port is None:
             vcsserver_port = get_available_port()
@@ -151,7 +154,7 b' def vcsserver_factory(tmpdir_factory):'
             overrides.append(platform_override)
 
         option_name = (
-            'vcsserver_config_http' if use_http else 'vcsserver_config')
+            'vcsserver_config_http' if use_http else 'vcsserver_config_pyro4')
         override_option_name = 'vcsserver_config_override'
         config_file = get_config(
             request.config, option_name=option_name,
@@ -183,10 +186,15 b' def _use_vcs_http_server(config):'
     protocol = (
         config.getoption(protocol_option) or
         config.getini(protocol_option) or
-        'pyro4')
+        'http')
     return protocol == 'http'
 
 
+def _use_log_level(config):
+    level = config.getoption('test_loglevel') or 'warn'
+    return level.upper()
+
+
 class VCSServer(object):
     """
     Represents a running VCSServer instance.
@@ -196,7 +204,7 b' class VCSServer(object):'
 
     def start(self):
         print("Starting the VCSServer: {}".format(self._args))
-        self.process = subprocess.Popen(self._args)
+        self.process = subprocess32.Popen(self._args)
 
     def wait_until_ready(self, timeout=30):
         raise NotImplementedError()
@@ -218,7 +226,8 b' class Pyro4VCSServer(VCSServer):'
         self._args = args
 
     def wait_until_ready(self, timeout=30):
-        remote_server = vcs.create_vcsserver_proxy(self.server_and_port)
+        remote_server = vcs.create_vcsserver_proxy(
+            self.server_and_port, 'pyro4')
         start = time.time()
         with remote_server:
             while time.time() - start < timeout:
@@ -245,7 +254,7 b' class HttpVCSServer(VCSServer):'
         config_data = configobj.ConfigObj(config_file)
         self._config = config_data['server:main']
 
-        args = ['pserve', config_file, 'http_host=0.0.0.0']
+        args = ['pserve', config_file]
         self._args = args
 
     @property
@@ -254,7 +263,7 b' class HttpVCSServer(VCSServer):'
         return template.format(**self._config)
 
     def start(self):
-        self.process = subprocess.Popen(self._args)
+        self.process = subprocess32.Popen(self._args)
 
     def wait_until_ready(self, timeout=30):
         host = self._config['host']
@@ -280,12 +289,41 b' class HttpVCSServer(VCSServer):'
 @pytest.fixture(scope='session')
 def pylons_config(request, tmpdir_factory, rcserver_port, vcsserver_port):
     option_name = 'pylons_config'
+    log_level = _use_log_level(request.config)
 
     overrides = [
         {'server:main': {'port': rcserver_port}},
-        {'app:main': {'vcs.server': 'localhost:%s' % vcsserver_port}}]
+        {'app:main': {
+            'vcs.server': 'localhost:%s' % vcsserver_port,
+            # johbo: We will always start the VCSServer on our own based on the
+            # fixtures of the test cases. For the test run it must always be
+            # off in the INI file.
+            'vcs.start_server': 'false',
+        }},
+
+        {'handler_console': {
+            'class ': 'StreamHandler',
+            'args ': '(sys.stderr,)',
+            'level': log_level,
+        }},
+
+    ]
     if _use_vcs_http_server(request.config):
-        overrides.append({'app:main': {'vcs.server.protocol': 'http'}})
+        overrides.append({
+            'app:main': {
+                'vcs.server.protocol': 'http',
+                'vcs.scm_app_implementation': 'http',
+                'vcs.hooks.protocol': 'http',
+            }
+        })
+    else:
+        overrides.append({
+            'app:main': {
+                'vcs.server.protocol': 'pyro4',
+                'vcs.scm_app_implementation': 'pyro4',
+                'vcs.hooks.protocol': 'pyro4',
+            }
+        })
 
     filename = get_config(
         request.config, option_name=option_name,
@@ -345,6 +383,7 b' def available_port(available_port_factor'
 
 @pytest.fixture(scope='session')
 def pylonsapp(pylons_config, vcsserver, http_environ_session):
+    print "Using the RhodeCode configuration", pylons_config
     logging.config.fileConfig(
         pylons_config, disable_existing_loggers=False)
     app = _setup_pylons_environment(pylons_config, http_environ_session)

rhodecode/tests/scripts/test_concurency.py

@@ -30,10 +30,8 b' from os.path import join as jn'
 from os.path import dirname as dn
 
 from tempfile import _RandomNameSequence
-from subprocess import Popen, PIPE
-
+from subprocess32 import Popen, PIPE
 from paste.deploy import appconfig
-from pylons import config
 
 from rhodecode.lib.utils import add_cache
 from rhodecode.lib.utils2 import engine_from_config
@@ -42,7 +40,7 b' from rhodecode.model import init_model'
 from rhodecode.model import meta
 from rhodecode.model.db import User, Repository
 
-from rhodecode.tests import TESTS_TMP_PATH, NEW_HG_REPO, HG_REPO
+from rhodecode.tests import TESTS_TMP_PATH, HG_REPO
 from rhodecode.config.environment import load_environment
 
 rel_path = dn(dn(dn(dn(os.path.abspath(__file__)))))

rhodecode/tests/utils.py

@@ -22,7 +22,7 b' import threading'
 import time
 import logging
 import os.path
-import subprocess
+import subprocess32
 import urllib2
 from urlparse import urlparse, parse_qsl
 from urllib import unquote_plus
@@ -113,10 +113,10 b' def _load_svn_dump_into_repo(dump_name, '
     integrated with the main repository once they stabilize more.
     """
     dump = rc_testdata.load_svn_dump(dump_name)
-    load_dump = subprocess.Popen(
+    load_dump = subprocess32.Popen(
         ['svnadmin', 'load', repo_path],
-        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE)
+        stdin=subprocess32.PIPE, stdout=subprocess32.PIPE,
+        stderr=subprocess32.PIPE)
     out, err = load_dump.communicate(dump)
     if load_dump.returncode != 0:
         log.error("Output of load_dump command: %s", out)
@@ -149,6 +149,10 b' class AssertResponse(object):'
         element = self.get_element(css_selector)
         assert expected_content in element.text_content()
 
+    def element_value_contains(self, css_selector, expected_content):
+        element = self.get_element(css_selector)
+        assert expected_content in element.value
+
     def contains_one_link(self, link_text, href):
         doc = fromstring(self.response.body)
         sel = CSSSelector('a[href]')

rhodecode/tests/vcs/test_client_http.py

@@ -70,7 +70,7 b' def stub_session_factory(stub_session):'
 
 def test_repo_maker_uses_session_for_classmethods(stub_session_factory):
     repo_maker = client_http.RepoMaker(
-        'server_and_port', 'endpoint', stub_session_factory)
+        'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
     repo_maker.example_call()
     stub_session_factory().post.assert_called_with(
         'http://server_and_port/endpoint', data=mock.ANY)
@@ -79,7 +79,7 b' def test_repo_maker_uses_session_for_cla'
 def test_repo_maker_uses_session_for_instance_methods(
         stub_session_factory, config):
     repo_maker = client_http.RepoMaker(
-        'server_and_port', 'endpoint', stub_session_factory)
+        'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
     repo = repo_maker('stub_path', config)
     repo.example_call()
     stub_session_factory().post.assert_called_with(

rhodecode/tests/vcs/test_commits.py

@@ -465,6 +465,19 b' class TestCommits(BackendTestMixin):'
         with pytest.raises(TypeError):
             self.repo.get_commits(start_id=1, end_id=2)
 
+    def test_commit_equality(self):
+        commit1 = self.repo.get_commit(self.repo.commit_ids[0])
+        commit2 = self.repo.get_commit(self.repo.commit_ids[1])
+
+        assert commit1 == commit1
+        assert commit2 == commit2
+        assert commit1 != commit2
+        assert commit2 != commit1
+        assert commit1 != None
+        assert None != commit1
+        assert 1 != commit1
+        assert 'string' != commit1
+
 
 @pytest.mark.parametrize("filename, expected", [
     ("README.rst", False),

rhodecode/tests/vcs/test_hg.py

@@ -599,7 +599,7 b' TODO: To be written...'
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
-            True, True, merge_response.merge_commit_id,
+            True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
@@ -611,14 +611,14 b' TODO: To be written...'
         assert target_ref.commit_id in commit_ids
 
         merge_commit = target_commits[-1]
-        assert merge_commit.raw_id == merge_response.merge_commit_id
+        assert merge_commit.raw_id == merge_response.merge_ref.commit_id
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
         # Check the bookmark was updated in the target repo
         assert (
             target_repo.bookmarks[bookmark_name] ==
-            merge_response.merge_commit_id)
+            merge_response.merge_ref.commit_id)
 
     def test_merge_source_is_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
@@ -643,7 +643,7 b' TODO: To be written...'
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
-            True, True, merge_response.merge_commit_id,
+            True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
@@ -717,7 +717,7 b' TODO: To be written...'
             dry_run=False, use_rebase=True)
 
         expected_merge_response = MergeResponse(
-            True, True, merge_response.merge_commit_id,
+            True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 

rhodecode/tests/vcs/test_repository.py

@@ -308,7 +308,7 b' class TestRepositoryMerge:'
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
-            True, True, merge_response.merge_commit_id,
+            True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
@@ -320,45 +320,55 b' class TestRepositoryMerge:'
         assert self.target_ref.commit_id in commit_ids
 
         merge_commit = target_commits[-1]
-        assert merge_commit.raw_id == merge_response.merge_commit_id
+        assert merge_commit.raw_id == merge_response.merge_ref.commit_id
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
         # We call it twice so to make sure we can handle updates
         target_ref = Reference(
             self.target_ref.type, self.target_ref.name,
-            merge_response.merge_commit_id)
+            merge_response.merge_ref.commit_id)
 
         merge_response = target_repo.merge(
             target_ref, self.source_repo, self.source_ref, self.workspace,
             'test user', '[e-mail]', 'merge message 2',
             dry_run=False)
         expected_merge_response = MergeResponse(
-            True, True, merge_response.merge_commit_id,
+            True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(
             vcsbackend.alias)(self.target_repo.path)
-        merge_commit = target_repo.get_commit(merge_response.merge_commit_id)
+        merge_commit = target_repo.get_commit(
+            merge_response.merge_ref.commit_id)
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
     def test_merge_success_dry_run(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
-        expected_merge_response = MergeResponse(
-            True, False, None, MergeFailureReason.NONE)
 
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             dry_run=True)
-        assert merge_response == expected_merge_response
 
         # We call it twice so to make sure we can handle updates
-        merge_response = self.target_repo.merge(
+        merge_response_update = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             dry_run=True)
-        assert merge_response == expected_merge_response
+
+        # Multiple merges may differ in their commit id. Therefore we set the
+        # commit id to `None` before comparing the merge responses.
+        merge_response = merge_response._replace(
+            merge_ref=merge_response.merge_ref._replace(commit_id=None))
+        merge_response_update = merge_response_update._replace(
+            merge_ref=merge_response_update.merge_ref._replace(commit_id=None))
+
+        assert merge_response == merge_response_update
+        assert merge_response.possible is True
+        assert merge_response.executed is False
+        assert merge_response.merge_ref
+        assert merge_response.failure_reason is MergeFailureReason.NONE
 
     @pytest.mark.parametrize('dry_run', [True, False])
     def test_merge_conflict(self, vcsbackend, dry_run):
@@ -391,10 +401,10 b' class TestRepositoryMerge:'
 
         assert merge_response == expected_merge_response
 
-    def test_merge_missing_commit(self, vcsbackend):
+    def test_merge_missing_source_reference(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
         expected_merge_response = MergeResponse(
-            False, False, None, MergeFailureReason.MISSING_COMMIT)
+            False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
 
         source_ref = Reference(
             self.source_ref.type, 'not_existing', self.source_ref.commit_id)

rhodecode/tests/vcs/test_utils.py

@@ -20,7 +20,7 b''
 
 import datetime
 import os
-import subprocess
+import subprocess32
 
 import pytest
 
@@ -86,8 +86,8 b' class TestGetScm:'
     def test_get_two_scms_for_path(self, tmpdir):
         multialias_repo_path = str(tmpdir)
 
-        subprocess.check_call(['hg', 'init', multialias_repo_path])
-        subprocess.check_call(['git', 'init', multialias_repo_path])
+        subprocess32.check_call(['hg', 'init', multialias_repo_path])
+        subprocess32.check_call(['git', 'init', multialias_repo_path])
 
         with pytest.raises(VCSError):
             get_scm(multialias_repo_path)

rhodecode/tests/vcs/test_vcsclient.py

@@ -45,8 +45,8 b' def test_vcs_connections_have_a_timeout_'
     proxy_objects = []
     with pytest.raises(TimeoutError):
         # TODO: johbo: Find a better way to set this number
-        while xrange(100):
-            server = create_vcsserver_proxy(server_and_port)
+        for number in xrange(100):
+            server = create_vcsserver_proxy(server_and_port, protocol='pyro4')
             server.ping()
             proxy_objects.append(server)
 
@@ -54,7 +54,7 b' def test_vcs_connections_have_a_timeout_'
 def test_vcs_remote_calls_are_bound_by_timeout(pylonsapp, short_timeout):
     server_and_port = pylonsapp.config['vcs.server']
     with pytest.raises(TimeoutError):
-        server = create_vcsserver_proxy(server_and_port)
+        server = create_vcsserver_proxy(server_and_port, protocol='pyro4')
         server.sleep(short_timeout + 1.0)
 
 

rhodecode/tests/vcs/utils.py

@@ -27,7 +27,7 b' import os'
 import re
 import sys
 
-from subprocess import Popen
+from subprocess32 import Popen
 
 
 class VCSTestError(Exception):

rhodecode/translation.py

@@ -21,6 +21,7 b' from pyramid.i18n import TranslationStri'
 # Create a translation string factory for the 'rhodecode' domain.
 _ = TranslationStringFactory('rhodecode')
 
+
 class LazyString(object):
     def __init__(self, *args, **kw):
         self.args = args

setup.cfg

@@ -21,6 +21,7 b' keywords ='
     lazy_ugettext
     _ngettext
     _gettext
+    gettext_translator
 
 [init_catalog]
 domain = rhodecode

setup.py

@@ -51,6 +51,7 b' requirements = ['
     'PasteDeploy',
     'PasteScript',
     'Pygments',
+    'pygments-markdown-lexer',
     'Pylons',
     'Pyro4',
     'Routes',
@@ -101,6 +102,7 b' requirements = ['
     'repoze.lru',
     'requests',
     'simplejson',
+    'subprocess32',
     'waitress',
     'zope.cachedescriptors',
     'dogpile.cache',
@@ -117,12 +119,12 b' test_requirements = ['
     'WebTest',
     'configobj',
     'cssselect',
-    'flake8',
     'lxml',
     'mock',
     'pytest',
     'pytest-cov',
     'pytest-runner',
+    'pytest-sugar',
 ]
 
 setup_requirements = [

shell.nix

@@ -1,57 +1,83 b''
 { pkgs ? (import <nixpkgs> {})
-, vcsserverPath ? "./../rhodecode-vcsserver"
-, vcsserverNix ? "shell.nix"
+, pythonPackages ? "python27Packages"
 , doCheck ? true
+, sourcesOverrides ? {}
+, doDevelopInstall ? true
 }:
 
 let
-
-  # Convert vcsserverPath to absolute path.
-  vcsserverAbsPath =
-    if pkgs.lib.strings.hasPrefix "/" vcsserverPath then
-      builtins.toPath "${vcsserverPath}"
-    else
-      builtins.toPath ("${builtins.getEnv "PWD"}/${vcsserverPath}");
+  # Get sources from config and update them with overrides.
+  sources = (pkgs.config.rc.sources or {}) // sourcesOverrides;
 
-  # Import vcsserver if nix file exists, otherwise set it to null.
-  vcsserver =
-    let
-      nixFile = "${vcsserverAbsPath}/${vcsserverNix}";
-    in
-      if pkgs.lib.pathExists "${nixFile}" then
-        builtins.trace
-          "Using local vcsserver from ${nixFile}"
-          import "${nixFile}" {inherit pkgs;}
-      else
-          null;
-
-  hasVcsserver = !isNull vcsserver;
-
-  enterprise = import ./default.nix {
-    inherit pkgs doCheck;
+  enterprise-ce = import ./default.nix {
+    inherit pkgs pythonPackages doCheck;
   };
 
-  pythonPackages = enterprise.pythonPackages;
+  ce-pythonPackages = enterprise-ce.pythonPackages;
 
-in enterprise.override (attrs: {
+  # This method looks up a path from `pkgs.config.rc.sources` and returns a
+  # shell script which does a `python setup.py develop` installation of it. If
+  # no path is found it will return an empty string.
+  optionalDevelopInstall = attributeName:
+    let
+      path = pkgs.lib.attrByPath [attributeName] null sources;
+      doIt = doDevelopInstall && path != null;
+    in
+      pkgs.lib.optionalString doIt (
+      builtins.trace "Develop install of ${attributeName} from ${path}" ''
+        echo "Develop install of '${attributeName}' from '${path}' [BEGIN]"
+        pushd ${path}
+        python setup.py develop --prefix $tmp_path --allow-hosts ""
+        popd
+        echo "Develop install of '${attributeName}' from '${path}' [DONE]"
+      '');
+
+  # This method looks up a path from `pkgs.config.rc.sources` and imports the
+  # default.nix file if it exists. It returns the list of build inputs. If no
+  # path is found it will return an empty list.
+  optionalDevelopInstallBuildInputs = attributeName:
+    let
+      path = pkgs.lib.attrByPath [attributeName] null sources;
+      nixFile = "${path}/default.nix";
+      doIt = doDevelopInstall && path != null && pkgs.lib.pathExists "${nixFile}";
+      derivate = import "${nixFile}" {
+        inherit doCheck pkgs pythonPackages;
+      };
+    in
+      pkgs.lib.lists.optionals doIt derivate.propagatedNativeBuildInputs;
+
+  developInstalls = [ "rhodecode-vcsserver" ];
+
+in enterprise-ce.override (attrs: {
   # Avoid that we dump any sources into the store when entering the shell and
   # make development a little bit more convenient.
   src = null;
 
   buildInputs =
     attrs.buildInputs ++
-    pkgs.lib.optionals (hasVcsserver) vcsserver.propagatedNativeBuildInputs ++
-    (with pythonPackages; [
+    pkgs.lib.lists.concatMap optionalDevelopInstallBuildInputs developInstalls ++
+    (with ce-pythonPackages; [
       bumpversion
       invoke
       ipdb
     ]);
 
-  shellHook = attrs.shellHook +
-    pkgs.lib.strings.optionalString (hasVcsserver) ''
-      # Setup the vcsserver development egg.
-      pushd ${vcsserverAbsPath}
-      python setup.py develop --prefix $tmp_path --allow-hosts ""
-      popd
-    '';
+  # Somewhat snappier setup of the development environment
+  # TODO: think of supporting a stable path again, so that multiple shells
+  #       can share it.
+  preShellHook = enterprise-ce.linkNodeAndBowerPackages + ''
+    # Custom prompt to distinguish from other dev envs.
+    export PS1="\n\[\033[1;32m\][CE-shell:\w]$\[\033[0m\] "
+
+    # Setup a temporary directory.
+    tmp_path=$(mktemp -d)
+    export PATH="$tmp_path/bin:$PATH"
+    export PYTHONPATH="$tmp_path/${ce-pythonPackages.python.sitePackages}:$PYTHONPATH"
+    mkdir -p $tmp_path/${ce-pythonPackages.python.sitePackages}
+
+    # Develop installations
+    python setup.py develop --prefix $tmp_path --allow-hosts ""
+    echo "Additional develop installs"
+  '' + pkgs.lib.strings.concatMapStrings optionalDevelopInstall developInstalls;
+
 })

rhodecode/lib/annotate.py

@@ -1,214 +0,0 b''
-# -*- coding: utf-8 -*-
-
-# Copyright (C) 2011-2016  RhodeCode GmbH
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License, version 3
-# (only), as published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This program is dual-licensed. If you wish to learn more about the
-# RhodeCode Enterprise Edition, including its added features, Support services,
-# and proprietary license terms, please see https://rhodecode.com/licenses/
-
-
-"""
-Anontation library for usage in rhodecode, previously part of vcs
-"""
-
-import StringIO
-
-from pygments import highlight
-from pygments.formatters import HtmlFormatter
-
-from rhodecode.lib.vcs.exceptions import VCSError
-from rhodecode.lib.vcs.nodes import FileNode
-
-
-def annotate_highlight(
-        filenode, annotate_from_commit_func=None,
-        order=None, headers=None, **options):
-    """
-    Returns html portion containing annotated table with 3 columns: line
-    numbers, commit information and pygmentized line of code.
-
-    :param filenode: FileNode object
-    :param annotate_from_commit_func: function taking commit and
-      returning single annotate cell; needs break line at the end
-    :param order: ordered sequence of ``ls`` (line numbers column),
-      ``annotate`` (annotate column), ``code`` (code column); Default is
-      ``['ls', 'annotate', 'code']``
-    :param headers: dictionary with headers (keys are whats in ``order``
-      parameter)
-    """
-    from rhodecode.lib.helpers import get_lexer_for_filenode
-    options['linenos'] = True
-    formatter = AnnotateHtmlFormatter(
-        filenode=filenode, order=order, headers=headers,
-        annotate_from_commit_func=annotate_from_commit_func, **options)
-    lexer = get_lexer_for_filenode(filenode)
-    highlighted = highlight(filenode.content, lexer, formatter)
-    return highlighted
-
-
-class AnnotateHtmlFormatter(HtmlFormatter):
-
-    def __init__(
-            self, filenode, annotate_from_commit_func=None,
-            order=None, **options):
-        """
-        If ``annotate_from_commit_func`` is passed, it should be a function
-        which returns string from the given commit. For example, we may pass
-        following function as ``annotate_from_commit_func``::
-
-            def commit_to_anchor(commit):
-                return '<a href="/commits/%s/">%s</a>\n' %\
-                       (commit.id, commit.id)
-
-        :param annotate_from_commit_func: see above
-        :param order: (default: ``['ls', 'annotate', 'code']``); order of
-          columns;
-        :param options: standard pygment's HtmlFormatter options, there is
-          extra option tough, ``headers``. For instance we can pass::
-
-             formatter = AnnotateHtmlFormatter(filenode, headers={
-                'ls': '#',
-                'annotate': 'Annotate',
-                'code': 'Code',
-             })
-
-        """
-        super(AnnotateHtmlFormatter, self).__init__(**options)
-        self.annotate_from_commit_func = annotate_from_commit_func
-        self.order = order or ('ls', 'annotate', 'code')
-        headers = options.pop('headers', None)
-        if headers and not (
-                'ls' in headers and 'annotate' in headers and 'code' in headers):
-            raise ValueError(
-                "If headers option dict is specified it must "
-                "all 'ls', 'annotate' and 'code' keys")
-        self.headers = headers
-        if isinstance(filenode, FileNode):
-            self.filenode = filenode
-        else:
-            raise VCSError(
-                "This formatter expect FileNode parameter, not %r" %
-                type(filenode))
-
-    def annotate_from_commit(self, commit):
-        """
-        Returns full html line for single commit per annotated line.
-        """
-        if self.annotate_from_commit_func:
-            return self.annotate_from_commit_func(commit)
-        else:
-            return commit.id + '\n'
-
-    def _wrap_tablelinenos(self, inner):
-        dummyoutfile = StringIO.StringIO()
-        lncount = 0
-        for t, line in inner:
-            if t:
-                lncount += 1
-            dummyoutfile.write(line)
-
-        fl = self.linenostart
-        mw = len(str(lncount + fl - 1))
-        sp = self.linenospecial
-        st = self.linenostep
-        la = self.lineanchors
-        aln = self.anchorlinenos
-        if sp:
-            lines = []
-
-            for i in range(fl, fl + lncount):
-                if i % st == 0:
-                    if i % sp == 0:
-                        if aln:
-                            lines.append('<a href="#%s-%d" class="special">'
-                                         '%*d</a>' %
-                                         (la, i, mw, i))
-                        else:
-                            lines.append('<span class="special">'
-                                         '%*d</span>' % (mw, i))
-                    else:
-                        if aln:
-                            lines.append('<a href="#%s-%d">'
-                                         '%*d</a>' % (la, i, mw, i))
-                        else:
-                            lines.append('%*d' % (mw, i))
-                else:
-                    lines.append('')
-            ls = '\n'.join(lines)
-        else:
-            lines = []
-            for i in range(fl, fl + lncount):
-                if i % st == 0:
-                    if aln:
-                        lines.append('<a href="#%s-%d">%*d</a>' \
-                                     % (la, i, mw, i))
-                    else:
-                        lines.append('%*d' % (mw, i))
-                else:
-                    lines.append('')
-            ls = '\n'.join(lines)
-
-        cached = {}
-        annotate = []
-        for el in self.filenode.annotate:
-            commit_id = el[1]
-            if commit_id in cached:
-                result = cached[commit_id]
-            else:
-                commit = el[2]()
-                result = self.annotate_from_commit(commit)
-                cached[commit_id] = result
-            annotate.append(result)
-
-        annotate = ''.join(annotate)
-
-        # in case you wonder about the seemingly redundant <div> here:
-        # since the content in the other cell also is wrapped in a div,
-        # some browsers in some configurations seem to mess up the formatting.
-        '''
-        yield 0, ('<table class="%stable">' % self.cssclass +
-                  '<tr><td class="linenos"><div class="linenodiv"><pre>' +
-                  ls + '</pre></div></td>' +
-                  '<td class="code">')
-        yield 0, dummyoutfile.getvalue()
-        yield 0, '</td></tr></table>'
-
-        '''
-        headers_row = []
-        if self.headers:
-            headers_row = ['<tr class="annotate-header">']
-            for key in self.order:
-                td = ''.join(('<td>', self.headers[key], '</td>'))
-                headers_row.append(td)
-            headers_row.append('</tr>')
-
-        body_row_start = ['<tr>']
-        for key in self.order:
-            if key == 'ls':
-                body_row_start.append(
-                    '<td class="linenos"><div class="linenodiv"><pre>' +
-                    ls + '</pre></div></td>')
-            elif key == 'annotate':
-                body_row_start.append(
-                    '<td class="annotate"><div class="annotatediv"><pre>' +
-                    annotate + '</pre></div></td>')
-            elif key == 'code':
-                body_row_start.append('<td class="code">')
-        yield 0, ('<table class="%stable">' % self.cssclass +
-                  ''.join(headers_row) +
-                  ''.join(body_row_start)
-                  )
-        yield 0, dummyoutfile.getvalue()
-        yield 0, '</td></tr></table>'

rhodecode/public/js/jquery.flot.js

@@ -1,3168 +0,0 b''
-/* Javascript plotting library for jQuery, version 0.8.3.
-
-Copyright (c) 2007-2014 IOLA and Ole Laursen.
-Licensed under the MIT license.
-
-*/
-
-// first an inline dependency, jquery.colorhelpers.js, we inline it here
-// for convenience
-
-/* Plugin for jQuery for working with colors.
- *
- * Version 1.1.
- *
- * Inspiration from jQuery color animation plugin by John Resig.
- *
- * Released under the MIT license by Ole Laursen, October 2009.
- *
- * Examples:
- *
- *   $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString()
- *   var c = $.color.extract($("#mydiv"), 'background-color');
- *   console.log(c.r, c.g, c.b, c.a);
- *   $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)"
- *
- * Note that .scale() and .add() return the same modified object
- * instead of making a new one.
- *
- * V. 1.1: Fix error handling so e.g. parsing an empty string does
- * produce a color rather than just crashing.
- */
-(function($){$.color={};$.color.make=function(r,g,b,a){var o={};o.r=r||0;o.g=g||0;o.b=b||0;o.a=a!=null?a:1;o.add=function(c,d){for(var i=0;i<c.length;++i)o[c.charAt(i)]+=d;return o.normalize()};o.scale=function(c,f){for(var i=0;i<c.length;++i)o[c.charAt(i)]*=f;return o.normalize()};o.toString=function(){if(o.a>=1){return"rgb("+[o.r,o.g,o.b].join(",")+")"}else{return"rgba("+[o.r,o.g,o.b,o.a].join(",")+")"}};o.normalize=function(){function clamp(min,value,max){return value<min?min:value>max?max:value}o.r=clamp(0,parseInt(o.r),255);o.g=clamp(0,parseInt(o.g),255);o.b=clamp(0,parseInt(o.b),255);o.a=clamp(0,o.a,1);return o};o.clone=function(){return $.color.make(o.r,o.b,o.g,o.a)};return o.normalize()};$.color.extract=function(elem,css){var c;do{c=elem.css(css).toLowerCase();if(c!=""&&c!="transparent")break;elem=elem.parent()}while(elem.length&&!$.nodeName(elem.get(0),"body"));if(c=="rgba(0, 0, 0, 0)")c="transparent";return $.color.parse(c)};$.color.parse=function(str){var res,m=$.color.make;if(res=/rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(str))return m(parseInt(res[1],10),parseInt(res[2],10),parseInt(res[3],10));if(res=/rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str))return m(parseInt(res[1],10),parseInt(res[2],10),parseInt(res[3],10),parseFloat(res[4]));if(res=/rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(str))return m(parseFloat(res[1])*2.55,parseFloat(res[2])*2.55,parseFloat(res[3])*2.55);if(res=/rgba\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str))return m(parseFloat(res[1])*2.55,parseFloat(res[2])*2.55,parseFloat(res[3])*2.55,parseFloat(res[4]));if(res=/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str))return m(parseInt(res[1],16),parseInt(res[2],16),parseInt(res[3],16));if(res=/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str))return m(parseInt(res[1]+res[1],16),parseInt(res[2]+res[2],16),parseInt(res[3]+res[3],16));var name=$.trim(str).toLowerCase();if(name=="transparent")return m(255,255,255,0);else{res=lookupColors[name]||[0,0,0];return m(res[0],res[1],res[2])}};var lookupColors={aqua:[0,255,255],azure:[240,255,255],beige:[245,245,220],black:[0,0,0],blue:[0,0,255],brown:[165,42,42],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgrey:[169,169,169],darkgreen:[0,100,0],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkviolet:[148,0,211],fuchsia:[255,0,255],gold:[255,215,0],green:[0,128,0],indigo:[75,0,130],khaki:[240,230,140],lightblue:[173,216,230],lightcyan:[224,255,255],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightyellow:[255,255,224],lime:[0,255,0],magenta:[255,0,255],maroon:[128,0,0],navy:[0,0,128],olive:[128,128,0],orange:[255,165,0],pink:[255,192,203],purple:[128,0,128],violet:[128,0,128],red:[255,0,0],silver:[192,192,192],white:[255,255,255],yellow:[255,255,0]}})(jQuery);
-
-// the actual Flot code
-(function($) {
-
-	// Cache the prototype hasOwnProperty for faster access
-
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-    // A shim to provide 'detach' to jQuery versions prior to 1.4.  Using a DOM
-    // operation produces the same effect as detach, i.e. removing the element
-    // without touching its jQuery data.
-
-    // Do not merge this into Flot 0.9, since it requires jQuery 1.4.4+.
-
-    if (!$.fn.detach) {
-        $.fn.detach = function() {
-            return this.each(function() {
-                if (this.parentNode) {
-                    this.parentNode.removeChild( this );
-                }
-            });
-        };
-    }
-
-	///////////////////////////////////////////////////////////////////////////
-	// The Canvas object is a wrapper around an HTML5 <canvas> tag.
-	//
-	// @constructor
-	// @param {string} cls List of classes to apply to the canvas.
-	// @param {element} container Element onto which to append the canvas.
-	//
-	// Requiring a container is a little iffy, but unfortunately canvas
-	// operations don't work unless the canvas is attached to the DOM.
-
-	function Canvas(cls, container) {
-
-		var element = container.children("." + cls)[0];
-
-		if (element == null) {
-
-			element = document.createElement("canvas");
-			element.className = cls;
-
-			$(element).css({ direction: "ltr", position: "absolute", left: 0, top: 0 })
-				.appendTo(container);
-
-			// If HTML5 Canvas isn't available, fall back to [Ex|Flash]canvas
-
-			if (!element.getContext) {
-				if (window.G_vmlCanvasManager) {
-					element = window.G_vmlCanvasManager.initElement(element);
-				} else {
-					throw new Error("Canvas is not available. If you're using IE with a fall-back such as Excanvas, then there's either a mistake in your conditional include, or the page has no DOCTYPE and is rendering in Quirks Mode.");
-				}
-			}
-		}
-
-		this.element = element;
-
-		var context = this.context = element.getContext("2d");
-
-		// Determine the screen's ratio of physical to device-independent
-		// pixels.  This is the ratio between the canvas width that the browser
-		// advertises and the number of pixels actually present in that space.
-
-		// The iPhone 4, for example, has a device-independent width of 320px,
-		// but its screen is actually 640px wide.  It therefore has a pixel
-		// ratio of 2, while most normal devices have a ratio of 1.
-
-		var devicePixelRatio = window.devicePixelRatio || 1,
-			backingStoreRatio =
-				context.webkitBackingStorePixelRatio ||
-				context.mozBackingStorePixelRatio ||
-				context.msBackingStorePixelRatio ||
-				context.oBackingStorePixelRatio ||
-				context.backingStorePixelRatio || 1;
-
-		this.pixelRatio = devicePixelRatio / backingStoreRatio;
-
-		// Size the canvas to match the internal dimensions of its container
-
-		this.resize(container.width(), container.height());
-
-		// Collection of HTML div layers for text overlaid onto the canvas
-
-		this.textContainer = null;
-		this.text = {};
-
-		// Cache of text fragments and metrics, so we can avoid expensively
-		// re-calculating them when the plot is re-rendered in a loop.
-
-		this._textCache = {};
-	}
-
-	// Resizes the canvas to the given dimensions.
-	//
-	// @param {number} width New width of the canvas, in pixels.
-	// @param {number} width New height of the canvas, in pixels.
-
-	Canvas.prototype.resize = function(width, height) {
-
-		if (width <= 0 || height <= 0) {
-			throw new Error("Invalid dimensions for plot, width = " + width + ", height = " + height);
-		}
-
-		var element = this.element,
-			context = this.context,
-			pixelRatio = this.pixelRatio;
-
-		// Resize the canvas, increasing its density based on the display's
-		// pixel ratio; basically giving it more pixels without increasing the
-		// size of its element, to take advantage of the fact that retina
-		// displays have that many more pixels in the same advertised space.
-
-		// Resizing should reset the state (excanvas seems to be buggy though)
-
-		if (this.width != width) {
-			element.width = width * pixelRatio;
-			element.style.width = width + "px";
-			this.width = width;
-		}
-
-		if (this.height != height) {
-			element.height = height * pixelRatio;
-			element.style.height = height + "px";
-			this.height = height;
-		}
-
-		// Save the context, so we can reset in case we get replotted.  The
-		// restore ensure that we're really back at the initial state, and
-		// should be safe even if we haven't saved the initial state yet.
-
-		context.restore();
-		context.save();
-
-		// Scale the coordinate space to match the display density; so even though we
-		// may have twice as many pixels, we still want lines and other drawing to
-		// appear at the same size; the extra pixels will just make them crisper.
-
-		context.scale(pixelRatio, pixelRatio);
-	};
-
-	// Clears the entire canvas area, not including any overlaid HTML text
-
-	Canvas.prototype.clear = function() {
-		this.context.clearRect(0, 0, this.width, this.height);
-	};
-
-	// Finishes rendering the canvas, including managing the text overlay.
-
-	Canvas.prototype.render = function() {
-
-		var cache = this._textCache;
-
-		// For each text layer, add elements marked as active that haven't
-		// already been rendered, and remove those that are no longer active.
-
-		for (var layerKey in cache) {
-			if (hasOwnProperty.call(cache, layerKey)) {
-
-				var layer = this.getTextLayer(layerKey),
-					layerCache = cache[layerKey];
-
-				layer.hide();
-
-				for (var styleKey in layerCache) {
-					if (hasOwnProperty.call(layerCache, styleKey)) {
-						var styleCache = layerCache[styleKey];
-						for (var key in styleCache) {
-							if (hasOwnProperty.call(styleCache, key)) {
-
-								var positions = styleCache[key].positions;
-
-								for (var i = 0, position; position = positions[i]; i++) {
-									if (position.active) {
-										if (!position.rendered) {
-											layer.append(position.element);
-											position.rendered = true;
-										}
-									} else {
-										positions.splice(i--, 1);
-										if (position.rendered) {
-											position.element.detach();
-										}
-									}
-								}
-
-								if (positions.length == 0) {
-									delete styleCache[key];
-								}
-							}
-						}
-					}
-				}
-
-				layer.show();
-			}
-		}
-	};
-
-	// Creates (if necessary) and returns the text overlay container.
-	//
-	// @param {string} classes String of space-separated CSS classes used to
-	//     uniquely identify the text layer.
-	// @return {object} The jQuery-wrapped text-layer div.
-
-	Canvas.prototype.getTextLayer = function(classes) {
-
-		var layer = this.text[classes];
-
-		// Create the text layer if it doesn't exist
-
-		if (layer == null) {
-
-			// Create the text layer container, if it doesn't exist
-
-			if (this.textContainer == null) {
-				this.textContainer = $("<div class='flot-text'></div>")
-					.css({
-						position: "absolute",
-						top: 0,
-						left: 0,
-						bottom: 0,
-						right: 0,
-						'font-size': "smaller",
-						color: "#545454"
-					})
-					.insertAfter(this.element);
-			}
-
-			layer = this.text[classes] = $("<div></div>")
-				.addClass(classes)
-				.css({
-					position: "absolute",
-					top: 0,
-					left: 0,
-					bottom: 0,
-					right: 0
-				})
-				.appendTo(this.textContainer);
-		}
-
-		return layer;
-	};
-
-	// Creates (if necessary) and returns a text info object.
-	//
-	// The object looks like this:
-	//
-	// {
-	//     width: Width of the text's wrapper div.
-	//     height: Height of the text's wrapper div.
-	//     element: The jQuery-wrapped HTML div containing the text.
-	//     positions: Array of positions at which this text is drawn.
-	// }
-	//
-	// The positions array contains objects that look like this:
-	//
-	// {
-	//     active: Flag indicating whether the text should be visible.
-	//     rendered: Flag indicating whether the text is currently visible.
-	//     element: The jQuery-wrapped HTML div containing the text.
-	//     x: X coordinate at which to draw the text.
-	//     y: Y coordinate at which to draw the text.
-	// }
-	//
-	// Each position after the first receives a clone of the original element.
-	//
-	// The idea is that that the width, height, and general 'identity' of the
-	// text is constant no matter where it is placed; the placements are a
-	// secondary property.
-	//
-	// Canvas maintains a cache of recently-used text info objects; getTextInfo
-	// either returns the cached element or creates a new entry.
-	//
-	// @param {string} layer A string of space-separated CSS classes uniquely
-	//     identifying the layer containing this text.
-	// @param {string} text Text string to retrieve info for.
-	// @param {(string|object)=} font Either a string of space-separated CSS
-	//     classes or a font-spec object, defining the text's font and style.
-	// @param {number=} angle Angle at which to rotate the text, in degrees.
-	//     Angle is currently unused, it will be implemented in the future.
-	// @param {number=} width Maximum width of the text before it wraps.
-	// @return {object} a text info object.
-
-	Canvas.prototype.getTextInfo = function(layer, text, font, angle, width) {
-
-		var textStyle, layerCache, styleCache, info;
-
-		// Cast the value to a string, in case we were given a number or such
-
-		text = "" + text;
-
-		// If the font is a font-spec object, generate a CSS font definition
-
-		if (typeof font === "object") {
-			textStyle = font.style + " " + font.variant + " " + font.weight + " " + font.size + "px/" + font.lineHeight + "px " + font.family;
-		} else {
-			textStyle = font;
-		}
-
-		// Retrieve (or create) the cache for the text's layer and styles
-
-		layerCache = this._textCache[layer];
-
-		if (layerCache == null) {
-			layerCache = this._textCache[layer] = {};
-		}
-
-		styleCache = layerCache[textStyle];
-
-		if (styleCache == null) {
-			styleCache = layerCache[textStyle] = {};
-		}
-
-		info = styleCache[text];
-
-		// If we can't find a matching element in our cache, create a new one
-
-		if (info == null) {
-
-			var element = $("<div></div>").html(text)
-				.css({
-					position: "absolute",
-					'max-width': width,
-					top: -9999
-				})
-				.appendTo(this.getTextLayer(layer));
-
-			if (typeof font === "object") {
-				element.css({
-					font: textStyle,
-					color: font.color
-				});
-			} else if (typeof font === "string") {
-				element.addClass(font);
-			}
-
-			info = styleCache[text] = {
-				width: element.outerWidth(true),
-				height: element.outerHeight(true),
-				element: element,
-				positions: []
-			};
-
-			element.detach();
-		}
-
-		return info;
-	};
-
-	// Adds a text string to the canvas text overlay.
-	//
-	// The text isn't drawn immediately; it is marked as rendering, which will
-	// result in its addition to the canvas on the next render pass.
-	//
-	// @param {string} layer A string of space-separated CSS classes uniquely
-	//     identifying the layer containing this text.
-	// @param {number} x X coordinate at which to draw the text.
-	// @param {number} y Y coordinate at which to draw the text.
-	// @param {string} text Text string to draw.
-	// @param {(string|object)=} font Either a string of space-separated CSS
-	//     classes or a font-spec object, defining the text's font and style.
-	// @param {number=} angle Angle at which to rotate the text, in degrees.
-	//     Angle is currently unused, it will be implemented in the future.
-	// @param {number=} width Maximum width of the text before it wraps.
-	// @param {string=} halign Horizontal alignment of the text; either "left",
-	//     "center" or "right".
-	// @param {string=} valign Vertical alignment of the text; either "top",
-	//     "middle" or "bottom".
-
-	Canvas.prototype.addText = function(layer, x, y, text, font, angle, width, halign, valign) {
-
-		var info = this.getTextInfo(layer, text, font, angle, width),
-			positions = info.positions;
-
-		// Tweak the div's position to match the text's alignment
-
-		if (halign == "center") {
-			x -= info.width / 2;
-		} else if (halign == "right") {
-			x -= info.width;
-		}
-
-		if (valign == "middle") {
-			y -= info.height / 2;
-		} else if (valign == "bottom") {
-			y -= info.height;
-		}
-
-		// Determine whether this text already exists at this position.
-		// If so, mark it for inclusion in the next render pass.
-
-		for (var i = 0, position; position = positions[i]; i++) {
-			if (position.x == x && position.y == y) {
-				position.active = true;
-				return;
-			}
-		}
-
-		// If the text doesn't exist at this position, create a new entry
-
-		// For the very first position we'll re-use the original element,
-		// while for subsequent ones we'll clone it.
-
-		position = {
-			active: true,
-			rendered: false,
-			element: positions.length ? info.element.clone() : info.element,
-			x: x,
-			y: y
-		};
-
-		positions.push(position);
-
-		// Move the element to its final position within the container
-
-		position.element.css({
-			top: Math.round(y),
-			left: Math.round(x),
-			'text-align': halign	// In case the text wraps
-		});
-	};
-
-	// Removes one or more text strings from the canvas text overlay.
-	//
-	// If no parameters are given, all text within the layer is removed.
-	//
-	// Note that the text is not immediately removed; it is simply marked as
-	// inactive, which will result in its removal on the next render pass.
-	// This avoids the performance penalty for 'clear and redraw' behavior,
-	// where we potentially get rid of all text on a layer, but will likely
-	// add back most or all of it later, as when redrawing axes, for example.
-	//
-	// @param {string} layer A string of space-separated CSS classes uniquely
-	//     identifying the layer containing this text.
-	// @param {number=} x X coordinate of the text.
-	// @param {number=} y Y coordinate of the text.
-	// @param {string=} text Text string to remove.
-	// @param {(string|object)=} font Either a string of space-separated CSS
-	//     classes or a font-spec object, defining the text's font and style.
-	// @param {number=} angle Angle at which the text is rotated, in degrees.
-	//     Angle is currently unused, it will be implemented in the future.
-
-	Canvas.prototype.removeText = function(layer, x, y, text, font, angle) {
-		if (text == null) {
-			var layerCache = this._textCache[layer];
-			if (layerCache != null) {
-				for (var styleKey in layerCache) {
-					if (hasOwnProperty.call(layerCache, styleKey)) {
-						var styleCache = layerCache[styleKey];
-						for (var key in styleCache) {
-							if (hasOwnProperty.call(styleCache, key)) {
-								var positions = styleCache[key].positions;
-								for (var i = 0, position; position = positions[i]; i++) {
-									position.active = false;
-								}
-							}
-						}
-					}
-				}
-			}
-		} else {
-			var positions = this.getTextInfo(layer, text, font, angle).positions;
-			for (var i = 0, position; position = positions[i]; i++) {
-				if (position.x == x && position.y == y) {
-					position.active = false;
-				}
-			}
-		}
-	};
-
-	///////////////////////////////////////////////////////////////////////////
-	// The top-level container for the entire plot.
-
-    function Plot(placeholder, data_, options_, plugins) {
-        // data is on the form:
-        //   [ series1, series2 ... ]
-        // where series is either just the data as [ [x1, y1], [x2, y2], ... ]
-        // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label", ... }
-
-        var series = [],
-            options = {
-                // the color theme used for graphs
-                colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],
-                legend: {
-                    show: true,
-                    noColumns: 1, // number of colums in legend table
-                    labelFormatter: null, // fn: string -> string
-                    labelBoxBorderColor: "#ccc", // border color for the little label boxes
-                    container: null, // container (as jQuery object) to put legend in, null means default on top of graph
-                    position: "ne", // position of default legend container within plot
-                    margin: 5, // distance from grid edge to default legend container within plot
-                    backgroundColor: null, // null means auto-detect
-                    backgroundOpacity: 0.85, // set to 0 to avoid background
-                    sorted: null    // default to no legend sorting
-                },
-                xaxis: {
-                    show: null, // null = auto-detect, true = always, false = never
-                    position: "bottom", // or "top"
-                    mode: null, // null or "time"
-                    font: null, // null (derived from CSS in placeholder) or object like { size: 11, lineHeight: 13, style: "italic", weight: "bold", family: "sans-serif", variant: "small-caps" }
-                    color: null, // base color, labels, ticks
-                    tickColor: null, // possibly different color of ticks, e.g. "rgba(0,0,0,0.15)"
-                    transform: null, // null or f: number -> number to transform axis
-                    inverseTransform: null, // if transform is set, this should be the inverse function
-                    min: null, // min. value to show, null means set automatically
-                    max: null, // max. value to show, null means set automatically
-                    autoscaleMargin: null, // margin in % to add if auto-setting min/max
-                    ticks: null, // either [1, 3] or [[1, "a"], 3] or (fn: axis info -> ticks) or app. number of ticks for auto-ticks
-                    tickFormatter: null, // fn: number -> string
-                    labelWidth: null, // size of tick labels in pixels
-                    labelHeight: null,
-                    reserveSpace: null, // whether to reserve space even if axis isn't shown
-                    tickLength: null, // size in pixels of ticks, or "full" for whole line
-                    alignTicksWithAxis: null, // axis number or null for no sync
-                    tickDecimals: null, // no. of decimals, null means auto
-                    tickSize: null, // number or [number, "unit"]
-                    minTickSize: null // number or [number, "unit"]
-                },
-                yaxis: {
-                    autoscaleMargin: 0.02,
-                    position: "left" // or "right"
-                },
-                xaxes: [],
-                yaxes: [],
-                series: {
-                    points: {
-                        show: false,
-                        radius: 3,
-                        lineWidth: 2, // in pixels
-                        fill: true,
-                        fillColor: "#ffffff",
-                        symbol: "circle" // or callback
-                    },
-                    lines: {
-                        // we don't put in show: false so we can see
-                        // whether lines were actively disabled
-                        lineWidth: 2, // in pixels
-                        fill: false,
-                        fillColor: null,
-                        steps: false
-                        // Omit 'zero', so we can later default its value to
-                        // match that of the 'fill' option.
-                    },
-                    bars: {
-                        show: false,
-                        lineWidth: 2, // in pixels
-                        barWidth: 1, // in units of the x axis
-                        fill: true,
-                        fillColor: null,
-                        align: "left", // "left", "right", or "center"
-                        horizontal: false,
-                        zero: true
-                    },
-                    shadowSize: 3,
-                    highlightColor: null
-                },
-                grid: {
-                    show: true,
-                    aboveData: false,
-                    color: "#545454", // primary color used for outline and labels
-                    backgroundColor: null, // null for transparent, else color
-                    borderColor: null, // set if different from the grid color
-                    tickColor: null, // color for the ticks, e.g. "rgba(0,0,0,0.15)"
-                    margin: 0, // distance from the canvas edge to the grid
-                    labelMargin: 5, // in pixels
-                    axisMargin: 8, // in pixels
-                    borderWidth: 2, // in pixels
-                    minBorderMargin: null, // in pixels, null means taken from points radius
-                    markings: null, // array of ranges or fn: axes -> array of ranges
-                    markingsColor: "#f4f4f4",
-                    markingsLineWidth: 2,
-                    // interactive stuff
-                    clickable: false,
-                    hoverable: false,
-                    autoHighlight: true, // highlight in case mouse is near
-                    mouseActiveRadius: 10 // how far the mouse can be away to activate an item
-                },
-                interaction: {
-                    redrawOverlayInterval: 1000/60 // time between updates, -1 means in same flow
-                },
-                hooks: {}
-            },
-        surface = null,     // the canvas for the plot itself
-        overlay = null,     // canvas for interactive stuff on top of plot
-        eventHolder = null, // jQuery object that events should be bound to
-        ctx = null, octx = null,
-        xaxes = [], yaxes = [],
-        plotOffset = { left: 0, right: 0, top: 0, bottom: 0},
-        plotWidth = 0, plotHeight = 0,
-        hooks = {
-            processOptions: [],
-            processRawData: [],
-            processDatapoints: [],
-            processOffset: [],
-            drawBackground: [],
-            drawSeries: [],
-            draw: [],
-            bindEvents: [],
-            drawOverlay: [],
-            shutdown: []
-        },
-        plot = this;
-
-        // public functions
-        plot.setData = setData;
-        plot.setupGrid = setupGrid;
-        plot.draw = draw;
-        plot.getPlaceholder = function() { return placeholder; };
-        plot.getCanvas = function() { return surface.element; };
-        plot.getPlotOffset = function() { return plotOffset; };
-        plot.width = function () { return plotWidth; };
-        plot.height = function () { return plotHeight; };
-        plot.offset = function () {
-            var o = eventHolder.offset();
-            o.left += plotOffset.left;
-            o.top += plotOffset.top;
-            return o;
-        };
-        plot.getData = function () { return series; };
-        plot.getAxes = function () {
-            var res = {}, i;
-            $.each(xaxes.concat(yaxes), function (_, axis) {
-                if (axis)
-                    res[axis.direction + (axis.n != 1 ? axis.n : "") + "axis"] = axis;
-            });
-            return res;
-        };
-        plot.getXAxes = function () { return xaxes; };
-        plot.getYAxes = function () { return yaxes; };
-        plot.c2p = canvasToAxisCoords;
-        plot.p2c = axisToCanvasCoords;
-        plot.getOptions = function () { return options; };
-        plot.highlight = highlight;
-        plot.unhighlight = unhighlight;
-        plot.triggerRedrawOverlay = triggerRedrawOverlay;
-        plot.pointOffset = function(point) {
-            return {
-                left: parseInt(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left, 10),
-                top: parseInt(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top, 10)
-            };
-        };
-        plot.shutdown = shutdown;
-        plot.destroy = function () {
-            shutdown();
-            placeholder.removeData("plot").empty();
-
-            series = [];
-            options = null;
-            surface = null;
-            overlay = null;
-            eventHolder = null;
-            ctx = null;
-            octx = null;
-            xaxes = [];
-            yaxes = [];
-            hooks = null;
-            highlights = [];
-            plot = null;
-        };
-        plot.resize = function () {
-        	var width = placeholder.width(),
-        		height = placeholder.height();
-            surface.resize(width, height);
-            overlay.resize(width, height);
-        };
-
-        // public attributes
-        plot.hooks = hooks;
-
-        // initialize
-        initPlugins(plot);
-        parseOptions(options_);
-        setupCanvases();
-        setData(data_);
-        setupGrid();
-        draw();
-        bindEvents();
-
-
-        function executeHooks(hook, args) {
-            args = [plot].concat(args);
-            for (var i = 0; i < hook.length; ++i)
-                hook[i].apply(this, args);
-        }
-
-        function initPlugins() {
-
-            // References to key classes, allowing plugins to modify them
-
-            var classes = {
-                Canvas: Canvas
-            };
-
-            for (var i = 0; i < plugins.length; ++i) {
-                var p = plugins[i];
-                p.init(plot, classes);
-                if (p.options)
-                    $.extend(true, options, p.options);
-            }
-        }
-
-        function parseOptions(opts) {
-
-            $.extend(true, options, opts);
-
-            // $.extend merges arrays, rather than replacing them.  When less
-            // colors are provided than the size of the default palette, we
-            // end up with those colors plus the remaining defaults, which is
-            // not expected behavior; avoid it by replacing them here.
-
-            if (opts && opts.colors) {
-            	options.colors = opts.colors;
-            }
-
-            if (options.xaxis.color == null)
-                options.xaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();
-            if (options.yaxis.color == null)
-                options.yaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();
-
-            if (options.xaxis.tickColor == null) // grid.tickColor for back-compatibility
-                options.xaxis.tickColor = options.grid.tickColor || options.xaxis.color;
-            if (options.yaxis.tickColor == null) // grid.tickColor for back-compatibility
-                options.yaxis.tickColor = options.grid.tickColor || options.yaxis.color;
-
-            if (options.grid.borderColor == null)
-                options.grid.borderColor = options.grid.color;
-            if (options.grid.tickColor == null)
-                options.grid.tickColor = $.color.parse(options.grid.color).scale('a', 0.22).toString();
-
-            // Fill in defaults for axis options, including any unspecified
-            // font-spec fields, if a font-spec was provided.
-
-            // If no x/y axis options were provided, create one of each anyway,
-            // since the rest of the code assumes that they exist.
-
-            var i, axisOptions, axisCount,
-                fontSize = placeholder.css("font-size"),
-                fontSizeDefault = fontSize ? +fontSize.replace("px", "") : 13,
-                fontDefaults = {
-                    style: placeholder.css("font-style"),
-                    size: Math.round(0.8 * fontSizeDefault),
-                    variant: placeholder.css("font-variant"),
-                    weight: placeholder.css("font-weight"),
-                    family: placeholder.css("font-family")
-                };
-
-            axisCount = options.xaxes.length || 1;
-            for (i = 0; i < axisCount; ++i) {
-
-                axisOptions = options.xaxes[i];
-                if (axisOptions && !axisOptions.tickColor) {
-                    axisOptions.tickColor = axisOptions.color;
-                }
-
-                axisOptions = $.extend(true, {}, options.xaxis, axisOptions);
-                options.xaxes[i] = axisOptions;
-
-                if (axisOptions.font) {
-                    axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);
-                    if (!axisOptions.font.color) {
-                        axisOptions.font.color = axisOptions.color;
-                    }
-                    if (!axisOptions.font.lineHeight) {
-                        axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);
-                    }
-                }
-            }
-
-            axisCount = options.yaxes.length || 1;
-            for (i = 0; i < axisCount; ++i) {
-
-                axisOptions = options.yaxes[i];
-                if (axisOptions && !axisOptions.tickColor) {
-                    axisOptions.tickColor = axisOptions.color;
-                }
-
-                axisOptions = $.extend(true, {}, options.yaxis, axisOptions);
-                options.yaxes[i] = axisOptions;
-
-                if (axisOptions.font) {
-                    axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);
-                    if (!axisOptions.font.color) {
-                        axisOptions.font.color = axisOptions.color;
-                    }
-                    if (!axisOptions.font.lineHeight) {
-                        axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);
-                    }
-                }
-            }
-
-            // backwards compatibility, to be removed in future
-            if (options.xaxis.noTicks && options.xaxis.ticks == null)
-                options.xaxis.ticks = options.xaxis.noTicks;
-            if (options.yaxis.noTicks && options.yaxis.ticks == null)
-                options.yaxis.ticks = options.yaxis.noTicks;
-            if (options.x2axis) {
-                options.xaxes[1] = $.extend(true, {}, options.xaxis, options.x2axis);
-                options.xaxes[1].position = "top";
-                // Override the inherit to allow the axis to auto-scale
-                if (options.x2axis.min == null) {
-                    options.xaxes[1].min = null;
-                }
-                if (options.x2axis.max == null) {
-                    options.xaxes[1].max = null;
-                }
-            }
-            if (options.y2axis) {
-                options.yaxes[1] = $.extend(true, {}, options.yaxis, options.y2axis);
-                options.yaxes[1].position = "right";
-                // Override the inherit to allow the axis to auto-scale
-                if (options.y2axis.min == null) {
-                    options.yaxes[1].min = null;
-                }
-                if (options.y2axis.max == null) {
-                    options.yaxes[1].max = null;
-                }
-            }
-            if (options.grid.coloredAreas)
-                options.grid.markings = options.grid.coloredAreas;
-            if (options.grid.coloredAreasColor)
-                options.grid.markingsColor = options.grid.coloredAreasColor;
-            if (options.lines)
-                $.extend(true, options.series.lines, options.lines);
-            if (options.points)
-                $.extend(true, options.series.points, options.points);
-            if (options.bars)
-                $.extend(true, options.series.bars, options.bars);
-            if (options.shadowSize != null)
-                options.series.shadowSize = options.shadowSize;
-            if (options.highlightColor != null)
-                options.series.highlightColor = options.highlightColor;
-
-            // save options on axes for future reference
-            for (i = 0; i < options.xaxes.length; ++i)
-                getOrCreateAxis(xaxes, i + 1).options = options.xaxes[i];
-            for (i = 0; i < options.yaxes.length; ++i)
-                getOrCreateAxis(yaxes, i + 1).options = options.yaxes[i];
-
-            // add hooks from options
-            for (var n in hooks)
-                if (options.hooks[n] && options.hooks[n].length)
-                    hooks[n] = hooks[n].concat(options.hooks[n]);
-
-            executeHooks(hooks.processOptions, [options]);
-        }
-
-        function setData(d) {
-            series = parseData(d);
-            fillInSeriesOptions();
-            processData();
-        }
-
-        function parseData(d) {
-            var res = [];
-            for (var i = 0; i < d.length; ++i) {
-                var s = $.extend(true, {}, options.series);
-
-                if (d[i].data != null) {
-                    s.data = d[i].data; // move the data instead of deep-copy
-                    delete d[i].data;
-
-                    $.extend(true, s, d[i]);
-
-                    d[i].data = s.data;
-                }
-                else
-                    s.data = d[i];
-                res.push(s);
-            }
-
-            return res;
-        }
-
-        function axisNumber(obj, coord) {
-            var a = obj[coord + "axis"];
-            if (typeof a == "object") // if we got a real axis, extract number
-                a = a.n;
-            if (typeof a != "number")
-                a = 1; // default to first axis
-            return a;
-        }
-
-        function allAxes() {
-            // return flat array without annoying null entries
-            return $.grep(xaxes.concat(yaxes), function (a) { return a; });
-        }
-
-        function canvasToAxisCoords(pos) {
-            // return an object with x/y corresponding to all used axes
-            var res = {}, i, axis;
-            for (i = 0; i < xaxes.length; ++i) {
-                axis = xaxes[i];
-                if (axis && axis.used)
-                    res["x" + axis.n] = axis.c2p(pos.left);
-            }
-
-            for (i = 0; i < yaxes.length; ++i) {
-                axis = yaxes[i];
-                if (axis && axis.used)
-                    res["y" + axis.n] = axis.c2p(pos.top);
-            }
-
-            if (res.x1 !== undefined)
-                res.x = res.x1;
-            if (res.y1 !== undefined)
-                res.y = res.y1;
-
-            return res;
-        }
-
-        function axisToCanvasCoords(pos) {
-            // get canvas coords from the first pair of x/y found in pos
-            var res = {}, i, axis, key;
-
-            for (i = 0; i < xaxes.length; ++i) {
-                axis = xaxes[i];
-                if (axis && axis.used) {
-                    key = "x" + axis.n;
-                    if (pos[key] == null && axis.n == 1)
-                        key = "x";
-
-                    if (pos[key] != null) {
-                        res.left = axis.p2c(pos[key]);
-                        break;
-                    }
-                }
-            }
-
-            for (i = 0; i < yaxes.length; ++i) {
-                axis = yaxes[i];
-                if (axis && axis.used) {
-                    key = "y" + axis.n;
-                    if (pos[key] == null && axis.n == 1)
-                        key = "y";
-
-                    if (pos[key] != null) {
-                        res.top = axis.p2c(pos[key]);
-                        break;
-                    }
-                }
-            }
-
-            return res;
-        }
-
-        function getOrCreateAxis(axes, number) {
-            if (!axes[number - 1])
-                axes[number - 1] = {
-                    n: number, // save the number for future reference
-                    direction: axes == xaxes ? "x" : "y",
-                    options: $.extend(true, {}, axes == xaxes ? options.xaxis : options.yaxis)
-                };
-
-            return axes[number - 1];
-        }
-
-        function fillInSeriesOptions() {
-
-            var neededColors = series.length, maxIndex = -1, i;
-
-            // Subtract the number of series that already have fixed colors or
-            // color indexes from the number that we still need to generate.
-
-            for (i = 0; i < series.length; ++i) {
-                var sc = series[i].color;
-                if (sc != null) {
-                    neededColors--;
-                    if (typeof sc == "number" && sc > maxIndex) {
-                        maxIndex = sc;
-                    }
-                }
-            }
-
-            // If any of the series have fixed color indexes, then we need to
-            // generate at least as many colors as the highest index.
-
-            if (neededColors <= maxIndex) {
-                neededColors = maxIndex + 1;
-            }
-
-            // Generate all the colors, using first the option colors and then
-            // variations on those colors once they're exhausted.
-
-            var c, colors = [], colorPool = options.colors,
-                colorPoolSize = colorPool.length, variation = 0;
-
-            for (i = 0; i < neededColors; i++) {
-
-                c = $.color.parse(colorPool[i % colorPoolSize] || "#666");
-
-                // Each time we exhaust the colors in the pool we adjust
-                // a scaling factor used to produce more variations on
-                // those colors. The factor alternates negative/positive
-                // to produce lighter/darker colors.
-
-                // Reset the variation after every few cycles, or else
-                // it will end up producing only white or black colors.
-
-                if (i % colorPoolSize == 0 && i) {
-                    if (variation >= 0) {
-                        if (variation < 0.5) {
-                            variation = -variation - 0.2;
-                        } else variation = 0;
-                    } else variation = -variation;
-                }
-
-                colors[i] = c.scale('rgb', 1 + variation);
-            }
-
-            // Finalize the series options, filling in their colors
-
-            var colori = 0, s;
-            for (i = 0; i < series.length; ++i) {
-                s = series[i];
-
-                // assign colors
-                if (s.color == null) {
-                    s.color = colors[colori].toString();
-                    ++colori;
-                }
-                else if (typeof s.color == "number")
-                    s.color = colors[s.color].toString();
-
-                // turn on lines automatically in case nothing is set
-                if (s.lines.show == null) {
-                    var v, show = true;
-                    for (v in s)
-                        if (s[v] && s[v].show) {
-                            show = false;
-                            break;
-                        }
-                    if (show)
-                        s.lines.show = true;
-                }
-
-                // If nothing was provided for lines.zero, default it to match
-                // lines.fill, since areas by default should extend to zero.
-
-                if (s.lines.zero == null) {
-                    s.lines.zero = !!s.lines.fill;
-                }
-
-                // setup axes
-                s.xaxis = getOrCreateAxis(xaxes, axisNumber(s, "x"));
-                s.yaxis = getOrCreateAxis(yaxes, axisNumber(s, "y"));
-            }
-        }
-
-        function processData() {
-            var topSentry = Number.POSITIVE_INFINITY,
-                bottomSentry = Number.NEGATIVE_INFINITY,
-                fakeInfinity = Number.MAX_VALUE,
-                i, j, k, m, length,
-                s, points, ps, x, y, axis, val, f, p,
-                data, format;
-
-            function updateAxis(axis, min, max) {
-                if (min < axis.datamin && min != -fakeInfinity)
-                    axis.datamin = min;
-                if (max > axis.datamax && max != fakeInfinity)
-                    axis.datamax = max;
-            }
-
-            $.each(allAxes(), function (_, axis) {
-                // init axis
-                axis.datamin = topSentry;
-                axis.datamax = bottomSentry;
-                axis.used = false;
-            });
-
-            for (i = 0; i < series.length; ++i) {
-                s = series[i];
-                s.datapoints = { points: [] };
-
-                executeHooks(hooks.processRawData, [ s, s.data, s.datapoints ]);
-            }
-
-            // first pass: clean and copy data
-            for (i = 0; i < series.length; ++i) {
-                s = series[i];
-
-                data = s.data;
-                format = s.datapoints.format;
-
-                if (!format) {
-                    format = [];
-                    // find out how to copy
-                    format.push({ x: true, number: true, required: true });
-                    format.push({ y: true, number: true, required: true });
-
-                    if (s.bars.show || (s.lines.show && s.lines.fill)) {
-                        var autoscale = !!((s.bars.show && s.bars.zero) || (s.lines.show && s.lines.zero));
-                        format.push({ y: true, number: true, required: false, defaultValue: 0, autoscale: autoscale });
-                        if (s.bars.horizontal) {
-                            delete format[format.length - 1].y;
-                            format[format.length - 1].x = true;
-                        }
-                    }
-
-                    s.datapoints.format = format;
-                }
-
-                if (s.datapoints.pointsize != null)
-                    continue; // already filled in
-
-                s.datapoints.pointsize = format.length;
-
-                ps = s.datapoints.pointsize;
-                points = s.datapoints.points;
-
-                var insertSteps = s.lines.show && s.lines.steps;
-                s.xaxis.used = s.yaxis.used = true;
-
-                for (j = k = 0; j < data.length; ++j, k += ps) {
-                    p = data[j];
-
-                    var nullify = p == null;
-                    if (!nullify) {
-                        for (m = 0; m < ps; ++m) {
-                            val = p[m];
-                            f = format[m];
-
-                            if (f) {
-                                if (f.number && val != null) {
-                                    val = +val; // convert to number
-                                    if (isNaN(val))
-                                        val = null;
-                                    else if (val == Infinity)
-                                        val = fakeInfinity;
-                                    else if (val == -Infinity)
-                                        val = -fakeInfinity;
-                                }
-
-                                if (val == null) {
-                                    if (f.required)
-                                        nullify = true;
-
-                                    if (f.defaultValue != null)
-                                        val = f.defaultValue;
-                                }
-                            }
-
-                            points[k + m] = val;
-                        }
-                    }
-
-                    if (nullify) {
-                        for (m = 0; m < ps; ++m) {
-                            val = points[k + m];
-                            if (val != null) {
-                                f = format[m];
-                                // extract min/max info
-                                if (f.autoscale !== false) {
-                                    if (f.x) {
-                                        updateAxis(s.xaxis, val, val);
-                                    }
-                                    if (f.y) {
-                                        updateAxis(s.yaxis, val, val);
-                                    }
-                                }
-                            }
-                            points[k + m] = null;
-                        }
-                    }
-                    else {
-                        // a little bit of line specific stuff that
-                        // perhaps shouldn't be here, but lacking
-                        // better means...
-                        if (insertSteps && k > 0
-                            && points[k - ps] != null
-                            && points[k - ps] != points[k]
-                            && points[k - ps + 1] != points[k + 1]) {
-                            // copy the point to make room for a middle point
-                            for (m = 0; m < ps; ++m)
-                                points[k + ps + m] = points[k + m];
-
-                            // middle point has same y
-                            points[k + 1] = points[k - ps + 1];
-
-                            // we've added a point, better reflect that
-                            k += ps;
-                        }
-                    }
-                }
-            }
-
-            // give the hooks a chance to run
-            for (i = 0; i < series.length; ++i) {
-                s = series[i];
-
-                executeHooks(hooks.processDatapoints, [ s, s.datapoints]);
-            }
-
-            // second pass: find datamax/datamin for auto-scaling
-            for (i = 0; i < series.length; ++i) {
-                s = series[i];
-                points = s.datapoints.points;
-                ps = s.datapoints.pointsize;
-                format = s.datapoints.format;
-
-                var xmin = topSentry, ymin = topSentry,
-                    xmax = bottomSentry, ymax = bottomSentry;
-
-                for (j = 0; j < points.length; j += ps) {
-                    if (points[j] == null)
-                        continue;
-
-                    for (m = 0; m < ps; ++m) {
-                        val = points[j + m];
-                        f = format[m];
-                        if (!f || f.autoscale === false || val == fakeInfinity || val == -fakeInfinity)
-                            continue;
-
-                        if (f.x) {
-                            if (val < xmin)
-                                xmin = val;
-                            if (val > xmax)
-                                xmax = val;
-                        }
-                        if (f.y) {
-                            if (val < ymin)
-                                ymin = val;
-                            if (val > ymax)
-                                ymax = val;
-                        }
-                    }
-                }
-
-                if (s.bars.show) {
-                    // make sure we got room for the bar on the dancing floor
-                    var delta;
-
-                    switch (s.bars.align) {
-                        case "left":
-                            delta = 0;
-                            break;
-                        case "right":
-                            delta = -s.bars.barWidth;
-                            break;
-                        default:
-                            delta = -s.bars.barWidth / 2;
-                    }
-
-                    if (s.bars.horizontal) {
-                        ymin += delta;
-                        ymax += delta + s.bars.barWidth;
-                    }
-                    else {
-                        xmin += delta;
-                        xmax += delta + s.bars.barWidth;
-                    }
-                }
-
-                updateAxis(s.xaxis, xmin, xmax);
-                updateAxis(s.yaxis, ymin, ymax);
-            }
-
-            $.each(allAxes(), function (_, axis) {
-                if (axis.datamin == topSentry)
-                    axis.datamin = null;
-                if (axis.datamax == bottomSentry)
-                    axis.datamax = null;
-            });
-        }
-
-        function setupCanvases() {
-
-            // Make sure the placeholder is clear of everything except canvases
-            // from a previous plot in this container that we'll try to re-use.
-
-            placeholder.css("padding", 0) // padding messes up the positioning
-                .children().filter(function(){
-                    return !$(this).hasClass("flot-overlay") && !$(this).hasClass('flot-base');
-                }).remove();
-
-            if (placeholder.css("position") == 'static')
-                placeholder.css("position", "relative"); // for positioning labels and overlay
-
-            surface = new Canvas("flot-base", placeholder);
-            overlay = new Canvas("flot-overlay", placeholder); // overlay canvas for interactive features
-
-            ctx = surface.context;
-            octx = overlay.context;
-
-            // define which element we're listening for events on
-            eventHolder = $(overlay.element).unbind();
-
-            // If we're re-using a plot object, shut down the old one
-
-            var existing = placeholder.data("plot");
-
-            if (existing) {
-                existing.shutdown();
-                overlay.clear();
-            }
-
-            // save in case we get replotted
-            placeholder.data("plot", plot);
-        }
-
-        function bindEvents() {
-            // bind events
-            if (options.grid.hoverable) {
-                eventHolder.mousemove(onMouseMove);
-
-                // Use bind, rather than .mouseleave, because we officially
-                // still support jQuery 1.2.6, which doesn't define a shortcut
-                // for mouseenter or mouseleave.  This was a bug/oversight that
-                // was fixed somewhere around 1.3.x.  We can return to using
-                // .mouseleave when we drop support for 1.2.6.
-
-                eventHolder.bind("mouseleave", onMouseLeave);
-            }
-
-            if (options.grid.clickable)
-                eventHolder.click(onClick);
-
-            executeHooks(hooks.bindEvents, [eventHolder]);
-        }
-
-        function shutdown() {
-            if (redrawTimeout)
-                clearTimeout(redrawTimeout);
-
-            eventHolder.unbind("mousemove", onMouseMove);
-            eventHolder.unbind("mouseleave", onMouseLeave);
-            eventHolder.unbind("click", onClick);
-
-            executeHooks(hooks.shutdown, [eventHolder]);
-        }
-
-        function setTransformationHelpers(axis) {
-            // set helper functions on the axis, assumes plot area
-            // has been computed already
-
-            function identity(x) { return x; }
-
-            var s, m, t = axis.options.transform || identity,
-                it = axis.options.inverseTransform;
-
-            // precompute how much the axis is scaling a point
-            // in canvas space
-            if (axis.direction == "x") {
-                s = axis.scale = plotWidth / Math.abs(t(axis.max) - t(axis.min));
-                m = Math.min(t(axis.max), t(axis.min));
-            }
-            else {
-                s = axis.scale = plotHeight / Math.abs(t(axis.max) - t(axis.min));
-                s = -s;
-                m = Math.max(t(axis.max), t(axis.min));
-            }
-
-            // data point to canvas coordinate
-            if (t == identity) // slight optimization
-                axis.p2c = function (p) { return (p - m) * s; };
-            else
-                axis.p2c = function (p) { return (t(p) - m) * s; };
-            // canvas coordinate to data point
-            if (!it)
-                axis.c2p = function (c) { return m + c / s; };
-            else
-                axis.c2p = function (c) { return it(m + c / s); };
-        }
-
-        function measureTickLabels(axis) {
-
-            var opts = axis.options,
-                ticks = axis.ticks || [],
-                labelWidth = opts.labelWidth || 0,
-                labelHeight = opts.labelHeight || 0,
-                maxWidth = labelWidth || (axis.direction == "x" ? Math.floor(surface.width / (ticks.length || 1)) : null),
-                legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",
-                layer = "flot-" + axis.direction + "-axis flot-" + axis.direction + axis.n + "-axis " + legacyStyles,
-                font = opts.font || "flot-tick-label tickLabel";
-
-            for (var i = 0; i < ticks.length; ++i) {
-
-                var t = ticks[i];
-
-                if (!t.label)
-                    continue;
-
-                var info = surface.getTextInfo(layer, t.label, font, null, maxWidth);
-
-                labelWidth = Math.max(labelWidth, info.width);
-                labelHeight = Math.max(labelHeight, info.height);
-            }
-
-            axis.labelWidth = opts.labelWidth || labelWidth;
-            axis.labelHeight = opts.labelHeight || labelHeight;
-        }
-
-        function allocateAxisBoxFirstPhase(axis) {
-            // find the bounding box of the axis by looking at label
-            // widths/heights and ticks, make room by diminishing the
-            // plotOffset; this first phase only looks at one
-            // dimension per axis, the other dimension depends on the
-            // other axes so will have to wait
-
-            var lw = axis.labelWidth,
-                lh = axis.labelHeight,
-                pos = axis.options.position,
-                isXAxis = axis.direction === "x",
-                tickLength = axis.options.tickLength,
-                axisMargin = options.grid.axisMargin,
-                padding = options.grid.labelMargin,
-                innermost = true,
-                outermost = true,
-                first = true,
-                found = false;
-
-            // Determine the axis's position in its direction and on its side
-
-            $.each(isXAxis ? xaxes : yaxes, function(i, a) {
-                if (a && (a.show || a.reserveSpace)) {
-                    if (a === axis) {
-                        found = true;
-                    } else if (a.options.position === pos) {
-                        if (found) {
-                            outermost = false;
-                        } else {
-                            innermost = false;
-                        }
-                    }
-                    if (!found) {
-                        first = false;
-                    }
-                }
-            });
-
-            // The outermost axis on each side has no margin
-
-            if (outermost) {
-                axisMargin = 0;
-            }
-
-            // The ticks for the first axis in each direction stretch across
-
-            if (tickLength == null) {
-                tickLength = first ? "full" : 5;
-            }
-
-            if (!isNaN(+tickLength))
-                padding += +tickLength;
-
-            if (isXAxis) {
-                lh += padding;
-
-                if (pos == "bottom") {
-                    plotOffset.bottom += lh + axisMargin;
-                    axis.box = { top: surface.height - plotOffset.bottom, height: lh };
-                }
-                else {
-                    axis.box = { top: plotOffset.top + axisMargin, height: lh };
-                    plotOffset.top += lh + axisMargin;
-                }
-            }
-            else {
-                lw += padding;
-
-                if (pos == "left") {
-                    axis.box = { left: plotOffset.left + axisMargin, width: lw };
-                    plotOffset.left += lw + axisMargin;
-                }
-                else {
-                    plotOffset.right += lw + axisMargin;
-                    axis.box = { left: surface.width - plotOffset.right, width: lw };
-                }
-            }
-
-             // save for future reference
-            axis.position = pos;
-            axis.tickLength = tickLength;
-            axis.box.padding = padding;
-            axis.innermost = innermost;
-        }
-
-        function allocateAxisBoxSecondPhase(axis) {
-            // now that all axis boxes have been placed in one
-            // dimension, we can set the remaining dimension coordinates
-            if (axis.direction == "x") {
-                axis.box.left = plotOffset.left - axis.labelWidth / 2;
-                axis.box.width = surface.width - plotOffset.left - plotOffset.right + axis.labelWidth;
-            }
-            else {
-                axis.box.top = plotOffset.top - axis.labelHeight / 2;
-                axis.box.height = surface.height - plotOffset.bottom - plotOffset.top + axis.labelHeight;
-            }
-        }
-
-        function adjustLayoutForThingsStickingOut() {
-            // possibly adjust plot offset to ensure everything stays
-            // inside the canvas and isn't clipped off
-
-            var minMargin = options.grid.minBorderMargin,
-                axis, i;
-
-            // check stuff from the plot (FIXME: this should just read
-            // a value from the series, otherwise it's impossible to
-            // customize)
-            if (minMargin == null) {
-                minMargin = 0;
-                for (i = 0; i < series.length; ++i)
-                    minMargin = Math.max(minMargin, 2 * (series[i].points.radius + series[i].points.lineWidth/2));
-            }
-
-            var margins = {
-                left: minMargin,
-                right: minMargin,
-                top: minMargin,
-                bottom: minMargin
-            };
-
-            // check axis labels, note we don't check the actual
-            // labels but instead use the overall width/height to not
-            // jump as much around with replots
-            $.each(allAxes(), function (_, axis) {
-                if (axis.reserveSpace && axis.ticks && axis.ticks.length) {
-                    if (axis.direction === "x") {
-                        margins.left = Math.max(margins.left, axis.labelWidth / 2);
-                        margins.right = Math.max(margins.right, axis.labelWidth / 2);
-                    } else {
-                        margins.bottom = Math.max(margins.bottom, axis.labelHeight / 2);
-                        margins.top = Math.max(margins.top, axis.labelHeight / 2);
-                    }
-                }
-            });
-
-            plotOffset.left = Math.ceil(Math.max(margins.left, plotOffset.left));
-            plotOffset.right = Math.ceil(Math.max(margins.right, plotOffset.right));
-            plotOffset.top = Math.ceil(Math.max(margins.top, plotOffset.top));
-            plotOffset.bottom = Math.ceil(Math.max(margins.bottom, plotOffset.bottom));
-        }
-
-        function setupGrid() {
-            var i, axes = allAxes(), showGrid = options.grid.show;
-
-            // Initialize the plot's offset from the edge of the canvas
-
-            for (var a in plotOffset) {
-                var margin = options.grid.margin || 0;
-                plotOffset[a] = typeof margin == "number" ? margin : margin[a] || 0;
-            }
-
-            executeHooks(hooks.processOffset, [plotOffset]);
-
-            // If the grid is visible, add its border width to the offset
-
-            for (var a in plotOffset) {
-                if(typeof(options.grid.borderWidth) == "object") {
-                    plotOffset[a] += showGrid ? options.grid.borderWidth[a] : 0;
-                }
-                else {
-                    plotOffset[a] += showGrid ? options.grid.borderWidth : 0;
-                }
-            }
-
-            $.each(axes, function (_, axis) {
-                var axisOpts = axis.options;
-                axis.show = axisOpts.show == null ? axis.used : axisOpts.show;
-                axis.reserveSpace = axisOpts.reserveSpace == null ? axis.show : axisOpts.reserveSpace;
-                setRange(axis);
-            });
-
-            if (showGrid) {
-
-                var allocatedAxes = $.grep(axes, function (axis) {
-                    return axis.show || axis.reserveSpace;
-                });
-
-                $.each(allocatedAxes, function (_, axis) {
-                    // make the ticks
-                    setupTickGeneration(axis);
-                    setTicks(axis);
-                    snapRangeToTicks(axis, axis.ticks);
-                    // find labelWidth/Height for axis
-                    measureTickLabels(axis);
-                });
-
-                // with all dimensions calculated, we can compute the
-                // axis bounding boxes, start from the outside
-                // (reverse order)
-                for (i = allocatedAxes.length - 1; i >= 0; --i)
-                    allocateAxisBoxFirstPhase(allocatedAxes[i]);
-
-                // make sure we've got enough space for things that
-                // might stick out
-                adjustLayoutForThingsStickingOut();
-
-                $.each(allocatedAxes, function (_, axis) {
-                    allocateAxisBoxSecondPhase(axis);
-                });
-            }
-
-            plotWidth = surface.width - plotOffset.left - plotOffset.right;
-            plotHeight = surface.height - plotOffset.bottom - plotOffset.top;
-
-            // now we got the proper plot dimensions, we can compute the scaling
-            $.each(axes, function (_, axis) {
-                setTransformationHelpers(axis);
-            });
-
-            if (showGrid) {
-                drawAxisLabels();
-            }
-
-            insertLegend();
-        }
-
-        function setRange(axis) {
-            var opts = axis.options,
-                min = +(opts.min != null ? opts.min : axis.datamin),
-                max = +(opts.max != null ? opts.max : axis.datamax),
-                delta = max - min;
-
-            if (delta == 0.0) {
-                // degenerate case
-                var widen = max == 0 ? 1 : 0.01;
-
-                if (opts.min == null)
-                    min -= widen;
-                // always widen max if we couldn't widen min to ensure we
-                // don't fall into min == max which doesn't work
-                if (opts.max == null || opts.min != null)
-                    max += widen;
-            }
-            else {
-                // consider autoscaling
-                var margin = opts.autoscaleMargin;
-                if (margin != null) {
-                    if (opts.min == null) {
-                        min -= delta * margin;
-                        // make sure we don't go below zero if all values
-                        // are positive
-                        if (min < 0 && axis.datamin != null && axis.datamin >= 0)
-                            min = 0;
-                    }
-                    if (opts.max == null) {
-                        max += delta * margin;
-                        if (max > 0 && axis.datamax != null && axis.datamax <= 0)
-                            max = 0;
-                    }
-                }
-            }
-            axis.min = min;
-            axis.max = max;
-        }
-
-        function setupTickGeneration(axis) {
-            var opts = axis.options;
-
-            // estimate number of ticks
-            var noTicks;
-            if (typeof opts.ticks == "number" && opts.ticks > 0)
-                noTicks = opts.ticks;
-            else
-                // heuristic based on the model a*sqrt(x) fitted to
-                // some data points that seemed reasonable
-                noTicks = 0.3 * Math.sqrt(axis.direction == "x" ? surface.width : surface.height);
-
-            var delta = (axis.max - axis.min) / noTicks,
-                dec = -Math.floor(Math.log(delta) / Math.LN10),
-                maxDec = opts.tickDecimals;
-
-            if (maxDec != null && dec > maxDec) {
-                dec = maxDec;
-            }
-
-            var magn = Math.pow(10, -dec),
-                norm = delta / magn, // norm is between 1.0 and 10.0
-                size;
-
-            if (norm < 1.5) {
-                size = 1;
-            } else if (norm < 3) {
-                size = 2;
-                // special case for 2.5, requires an extra decimal
-                if (norm > 2.25 && (maxDec == null || dec + 1 <= maxDec)) {
-                    size = 2.5;
-                    ++dec;
-                }
-            } else if (norm < 7.5) {
-                size = 5;
-            } else {
-                size = 10;
-            }
-
-            size *= magn;
-
-            if (opts.minTickSize != null && size < opts.minTickSize) {
-                size = opts.minTickSize;
-            }
-
-            axis.delta = delta;
-            axis.tickDecimals = Math.max(0, maxDec != null ? maxDec : dec);
-            axis.tickSize = opts.tickSize || size;
-
-            // Time mode was moved to a plug-in in 0.8, and since so many people use it
-            // we'll add an especially friendly reminder to make sure they included it.
-
-            if (opts.mode == "time" && !axis.tickGenerator) {
-                throw new Error("Time mode requires the flot.time plugin.");
-            }
-
-            // Flot supports base-10 axes; any other mode else is handled by a plug-in,
-            // like flot.time.js.
-
-            if (!axis.tickGenerator) {
-
-                axis.tickGenerator = function (axis) {
-
-                    var ticks = [],
-                        start = floorInBase(axis.min, axis.tickSize),
-                        i = 0,
-                        v = Number.NaN,
-                        prev;
-
-                    do {
-                        prev = v;
-                        v = start + i * axis.tickSize;
-                        ticks.push(v);
-                        ++i;
-                    } while (v < axis.max && v != prev);
-                    return ticks;
-                };
-
-				axis.tickFormatter = function (value, axis) {
-
-					var factor = axis.tickDecimals ? Math.pow(10, axis.tickDecimals) : 1;
-					var formatted = "" + Math.round(value * factor) / factor;
-
-					// If tickDecimals was specified, ensure that we have exactly that
-					// much precision; otherwise default to the value's own precision.
-
-					if (axis.tickDecimals != null) {
-						var decimal = formatted.indexOf(".");
-						var precision = decimal == -1 ? 0 : formatted.length - decimal - 1;
-						if (precision < axis.tickDecimals) {
-							return (precision ? formatted : formatted + ".") + ("" + factor).substr(1, axis.tickDecimals - precision);
-						}
-					}
-
-                    return formatted;
-                };
-            }
-
-            if ($.isFunction(opts.tickFormatter))
-                axis.tickFormatter = function (v, axis) { return "" + opts.tickFormatter(v, axis); };
-
-            if (opts.alignTicksWithAxis != null) {
-                var otherAxis = (axis.direction == "x" ? xaxes : yaxes)[opts.alignTicksWithAxis - 1];
-                if (otherAxis && otherAxis.used && otherAxis != axis) {
-                    // consider snapping min/max to outermost nice ticks
-                    var niceTicks = axis.tickGenerator(axis);
-                    if (niceTicks.length > 0) {
-                        if (opts.min == null)
-                            axis.min = Math.min(axis.min, niceTicks[0]);
-                        if (opts.max == null && niceTicks.length > 1)
-                            axis.max = Math.max(axis.max, niceTicks[niceTicks.length - 1]);
-                    }
-
-                    axis.tickGenerator = function (axis) {
-                        // copy ticks, scaled to this axis
-                        var ticks = [], v, i;
-                        for (i = 0; i < otherAxis.ticks.length; ++i) {
-                            v = (otherAxis.ticks[i].v - otherAxis.min) / (otherAxis.max - otherAxis.min);
-                            v = axis.min + v * (axis.max - axis.min);
-                            ticks.push(v);
-                        }
-                        return ticks;
-                    };
-
-                    // we might need an extra decimal since forced
-                    // ticks don't necessarily fit naturally
-                    if (!axis.mode && opts.tickDecimals == null) {
-                        var extraDec = Math.max(0, -Math.floor(Math.log(axis.delta) / Math.LN10) + 1),
-                            ts = axis.tickGenerator(axis);
-
-                        // only proceed if the tick interval rounded
-                        // with an extra decimal doesn't give us a
-                        // zero at end
-                        if (!(ts.length > 1 && /\..*0$/.test((ts[1] - ts[0]).toFixed(extraDec))))
-                            axis.tickDecimals = extraDec;
-                    }
-                }
-            }
-        }
-
-        function setTicks(axis) {
-            var oticks = axis.options.ticks, ticks = [];
-            if (oticks == null || (typeof oticks == "number" && oticks > 0))
-                ticks = axis.tickGenerator(axis);
-            else if (oticks) {
-                if ($.isFunction(oticks))
-                    // generate the ticks
-                    ticks = oticks(axis);
-                else
-                    ticks = oticks;
-            }
-
-            // clean up/labelify the supplied ticks, copy them over
-            var i, v;
-            axis.ticks = [];
-            for (i = 0; i < ticks.length; ++i) {
-                var label = null;
-                var t = ticks[i];
-                if (typeof t == "object") {
-                    v = +t[0];
-                    if (t.length > 1)
-                        label = t[1];
-                }
-                else
-                    v = +t;
-                if (label == null)
-                    label = axis.tickFormatter(v, axis);
-                if (!isNaN(v))
-                    axis.ticks.push({ v: v, label: label });
-            }
-        }
-
-        function snapRangeToTicks(axis, ticks) {
-            if (axis.options.autoscaleMargin && ticks.length > 0) {
-                // snap to ticks
-                if (axis.options.min == null)
-                    axis.min = Math.min(axis.min, ticks[0].v);
-                if (axis.options.max == null && ticks.length > 1)
-                    axis.max = Math.max(axis.max, ticks[ticks.length - 1].v);
-            }
-        }
-
-        function draw() {
-
-            surface.clear();
-
-            executeHooks(hooks.drawBackground, [ctx]);
-
-            var grid = options.grid;
-
-            // draw background, if any
-            if (grid.show && grid.backgroundColor)
-                drawBackground();
-
-            if (grid.show && !grid.aboveData) {
-                drawGrid();
-            }
-
-            for (var i = 0; i < series.length; ++i) {
-                executeHooks(hooks.drawSeries, [ctx, series[i]]);
-                drawSeries(series[i]);
-            }
-
-            executeHooks(hooks.draw, [ctx]);
-
-            if (grid.show && grid.aboveData) {
-                drawGrid();
-            }
-
-            surface.render();
-
-            // A draw implies that either the axes or data have changed, so we
-            // should probably update the overlay highlights as well.
-
-            triggerRedrawOverlay();
-        }
-
-        function extractRange(ranges, coord) {
-            var axis, from, to, key, axes = allAxes();
-
-            for (var i = 0; i < axes.length; ++i) {
-                axis = axes[i];
-                if (axis.direction == coord) {
-                    key = coord + axis.n + "axis";
-                    if (!ranges[key] && axis.n == 1)
-                        key = coord + "axis"; // support x1axis as xaxis
-                    if (ranges[key]) {
-                        from = ranges[key].from;
-                        to = ranges[key].to;
-                        break;
-                    }
-                }
-            }
-
-            // backwards-compat stuff - to be removed in future
-            if (!ranges[key]) {
-                axis = coord == "x" ? xaxes[0] : yaxes[0];
-                from = ranges[coord + "1"];
-                to = ranges[coord + "2"];
-            }
-
-            // auto-reverse as an added bonus
-            if (from != null && to != null && from > to) {
-                var tmp = from;
-                from = to;
-                to = tmp;
-            }
-
-            return { from: from, to: to, axis: axis };
-        }
-
-        function drawBackground() {
-            ctx.save();
-            ctx.translate(plotOffset.left, plotOffset.top);
-
-            ctx.fillStyle = getColorOrGradient(options.grid.backgroundColor, plotHeight, 0, "rgba(255, 255, 255, 0)");
-            ctx.fillRect(0, 0, plotWidth, plotHeight);
-            ctx.restore();
-        }
-
-        function drawGrid() {
-            var i, axes, bw, bc;
-
-            ctx.save();
-            ctx.translate(plotOffset.left, plotOffset.top);
-
-            // draw markings
-            var markings = options.grid.markings;
-            if (markings) {
-                if ($.isFunction(markings)) {
-                    axes = plot.getAxes();
-                    // xmin etc. is backwards compatibility, to be
-                    // removed in the future
-                    axes.xmin = axes.xaxis.min;
-                    axes.xmax = axes.xaxis.max;
-                    axes.ymin = axes.yaxis.min;
-                    axes.ymax = axes.yaxis.max;
-
-                    markings = markings(axes);
-                }
-
-                for (i = 0; i < markings.length; ++i) {
-                    var m = markings[i],
-                        xrange = extractRange(m, "x"),
-                        yrange = extractRange(m, "y");
-
-                    // fill in missing
-                    if (xrange.from == null)
-                        xrange.from = xrange.axis.min;
-                    if (xrange.to == null)
-                        xrange.to = xrange.axis.max;
-                    if (yrange.from == null)
-                        yrange.from = yrange.axis.min;
-                    if (yrange.to == null)
-                        yrange.to = yrange.axis.max;
-
-                    // clip
-                    if (xrange.to < xrange.axis.min || xrange.from > xrange.axis.max ||
-                        yrange.to < yrange.axis.min || yrange.from > yrange.axis.max)
-                        continue;
-
-                    xrange.from = Math.max(xrange.from, xrange.axis.min);
-                    xrange.to = Math.min(xrange.to, xrange.axis.max);
-                    yrange.from = Math.max(yrange.from, yrange.axis.min);
-                    yrange.to = Math.min(yrange.to, yrange.axis.max);
-
-                    var xequal = xrange.from === xrange.to,
-                        yequal = yrange.from === yrange.to;
-
-                    if (xequal && yequal) {
-                        continue;
-                    }
-
-                    // then draw
-                    xrange.from = Math.floor(xrange.axis.p2c(xrange.from));
-                    xrange.to = Math.floor(xrange.axis.p2c(xrange.to));
-                    yrange.from = Math.floor(yrange.axis.p2c(yrange.from));
-                    yrange.to = Math.floor(yrange.axis.p2c(yrange.to));
-
-                    if (xequal || yequal) {
-                        var lineWidth = m.lineWidth || options.grid.markingsLineWidth,
-                            subPixel = lineWidth % 2 ? 0.5 : 0;
-                        ctx.beginPath();
-                        ctx.strokeStyle = m.color || options.grid.markingsColor;
-                        ctx.lineWidth = lineWidth;
-                        if (xequal) {
-                            ctx.moveTo(xrange.to + subPixel, yrange.from);
-                            ctx.lineTo(xrange.to + subPixel, yrange.to);
-                        } else {
-                            ctx.moveTo(xrange.from, yrange.to + subPixel);
-                            ctx.lineTo(xrange.to, yrange.to + subPixel);                            
-                        }
-                        ctx.stroke();
-                    } else {
-                        ctx.fillStyle = m.color || options.grid.markingsColor;
-                        ctx.fillRect(xrange.from, yrange.to,
-                                     xrange.to - xrange.from,
-                                     yrange.from - yrange.to);
-                    }
-                }
-            }
-
-            // draw the ticks
-            axes = allAxes();
-            bw = options.grid.borderWidth;
-
-            for (var j = 0; j < axes.length; ++j) {
-                var axis = axes[j], box = axis.box,
-                    t = axis.tickLength, x, y, xoff, yoff;
-                if (!axis.show || axis.ticks.length == 0)
-                    continue;
-
-                ctx.lineWidth = 1;
-
-                // find the edges
-                if (axis.direction == "x") {
-                    x = 0;
-                    if (t == "full")
-                        y = (axis.position == "top" ? 0 : plotHeight);
-                    else
-                        y = box.top - plotOffset.top + (axis.position == "top" ? box.height : 0);
-                }
-                else {
-                    y = 0;
-                    if (t == "full")
-                        x = (axis.position == "left" ? 0 : plotWidth);
-                    else
-                        x = box.left - plotOffset.left + (axis.position == "left" ? box.width : 0);
-                }
-
-                // draw tick bar
-                if (!axis.innermost) {
-                    ctx.strokeStyle = axis.options.color;
-                    ctx.beginPath();
-                    xoff = yoff = 0;
-                    if (axis.direction == "x")
-                        xoff = plotWidth + 1;
-                    else
-                        yoff = plotHeight + 1;
-
-                    if (ctx.lineWidth == 1) {
-                        if (axis.direction == "x") {
-                            y = Math.floor(y) + 0.5;
-                        } else {
-                            x = Math.floor(x) + 0.5;
-                        }
-                    }
-
-                    ctx.moveTo(x, y);
-                    ctx.lineTo(x + xoff, y + yoff);
-                    ctx.stroke();
-                }
-
-                // draw ticks
-
-                ctx.strokeStyle = axis.options.tickColor;
-
-                ctx.beginPath();
-                for (i = 0; i < axis.ticks.length; ++i) {
-                    var v = axis.ticks[i].v;
-
-                    xoff = yoff = 0;
-
-                    if (isNaN(v) || v < axis.min || v > axis.max
-                        // skip those lying on the axes if we got a border
-                        || (t == "full"
-                            && ((typeof bw == "object" && bw[axis.position] > 0) || bw > 0)
-                            && (v == axis.min || v == axis.max)))
-                        continue;
-
-                    if (axis.direction == "x") {
-                        x = axis.p2c(v);
-                        yoff = t == "full" ? -plotHeight : t;
-
-                        if (axis.position == "top")
-                            yoff = -yoff;
-                    }
-                    else {
-                        y = axis.p2c(v);
-                        xoff = t == "full" ? -plotWidth : t;
-
-                        if (axis.position == "left")
-                            xoff = -xoff;
-                    }
-
-                    if (ctx.lineWidth == 1) {
-                        if (axis.direction == "x")
-                            x = Math.floor(x) + 0.5;
-                        else
-                            y = Math.floor(y) + 0.5;
-                    }
-
-                    ctx.moveTo(x, y);
-                    ctx.lineTo(x + xoff, y + yoff);
-                }
-
-                ctx.stroke();
-            }
-
-
-            // draw border
-            if (bw) {
-                // If either borderWidth or borderColor is an object, then draw the border
-                // line by line instead of as one rectangle
-                bc = options.grid.borderColor;
-                if(typeof bw == "object" || typeof bc == "object") {
-                    if (typeof bw !== "object") {
-                        bw = {top: bw, right: bw, bottom: bw, left: bw};
-                    }
-                    if (typeof bc !== "object") {
-                        bc = {top: bc, right: bc, bottom: bc, left: bc};
-                    }
-
-                    if (bw.top > 0) {
-                        ctx.strokeStyle = bc.top;
-                        ctx.lineWidth = bw.top;
-                        ctx.beginPath();
-                        ctx.moveTo(0 - bw.left, 0 - bw.top/2);
-                        ctx.lineTo(plotWidth, 0 - bw.top/2);
-                        ctx.stroke();
-                    }
-
-                    if (bw.right > 0) {
-                        ctx.strokeStyle = bc.right;
-                        ctx.lineWidth = bw.right;
-                        ctx.beginPath();
-                        ctx.moveTo(plotWidth + bw.right / 2, 0 - bw.top);
-                        ctx.lineTo(plotWidth + bw.right / 2, plotHeight);
-                        ctx.stroke();
-                    }
-
-                    if (bw.bottom > 0) {
-                        ctx.strokeStyle = bc.bottom;
-                        ctx.lineWidth = bw.bottom;
-                        ctx.beginPath();
-                        ctx.moveTo(plotWidth + bw.right, plotHeight + bw.bottom / 2);
-                        ctx.lineTo(0, plotHeight + bw.bottom / 2);
-                        ctx.stroke();
-                    }
-
-                    if (bw.left > 0) {
-                        ctx.strokeStyle = bc.left;
-                        ctx.lineWidth = bw.left;
-                        ctx.beginPath();
-                        ctx.moveTo(0 - bw.left/2, plotHeight + bw.bottom);
-                        ctx.lineTo(0- bw.left/2, 0);
-                        ctx.stroke();
-                    }
-                }
-                else {
-                    ctx.lineWidth = bw;
-                    ctx.strokeStyle = options.grid.borderColor;
-                    ctx.strokeRect(-bw/2, -bw/2, plotWidth + bw, plotHeight + bw);
-                }
-            }
-
-            ctx.restore();
-        }
-
-        function drawAxisLabels() {
-
-            $.each(allAxes(), function (_, axis) {
-                var box = axis.box,
-                    legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",
-                    layer = "flot-" + axis.direction + "-axis flot-" + axis.direction + axis.n + "-axis " + legacyStyles,
-                    font = axis.options.font || "flot-tick-label tickLabel",
-                    tick, x, y, halign, valign;
-
-                // Remove text before checking for axis.show and ticks.length;
-                // otherwise plugins, like flot-tickrotor, that draw their own
-                // tick labels will end up with both theirs and the defaults.
-
-                surface.removeText(layer);
-
-                if (!axis.show || axis.ticks.length == 0)
-                    return;
-
-                for (var i = 0; i < axis.ticks.length; ++i) {
-
-                    tick = axis.ticks[i];
-                    if (!tick.label || tick.v < axis.min || tick.v > axis.max)
-                        continue;
-
-                    if (axis.direction == "x") {
-                        halign = "center";
-                        x = plotOffset.left + axis.p2c(tick.v);
-                        if (axis.position == "bottom") {
-                            y = box.top + box.padding;
-                        } else {
-                            y = box.top + box.height - box.padding;
-                            valign = "bottom";
-                        }
-                    } else {
-                        valign = "middle";
-                        y = plotOffset.top + axis.p2c(tick.v);
-                        if (axis.position == "left") {
-                            x = box.left + box.width - box.padding;
-                            halign = "right";
-                        } else {
-                            x = box.left + box.padding;
-                        }
-                    }
-
-                    surface.addText(layer, x, y, tick.label, font, null, null, halign, valign);
-                }
-            });
-        }
-
-        function drawSeries(series) {
-            if (series.lines.show)
-                drawSeriesLines(series);
-            if (series.bars.show)
-                drawSeriesBars(series);
-            if (series.points.show)
-                drawSeriesPoints(series);
-        }
-
-        function drawSeriesLines(series) {
-            function plotLine(datapoints, xoffset, yoffset, axisx, axisy) {
-                var points = datapoints.points,
-                    ps = datapoints.pointsize,
-                    prevx = null, prevy = null;
-
-                ctx.beginPath();
-                for (var i = ps; i < points.length; i += ps) {
-                    var x1 = points[i - ps], y1 = points[i - ps + 1],
-                        x2 = points[i], y2 = points[i + 1];
-
-                    if (x1 == null || x2 == null)
-                        continue;
-
-                    // clip with ymin
-                    if (y1 <= y2 && y1 < axisy.min) {
-                        if (y2 < axisy.min)
-                            continue;   // line segment is outside
-                        // compute new intersection point
-                        x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y1 = axisy.min;
-                    }
-                    else if (y2 <= y1 && y2 < axisy.min) {
-                        if (y1 < axisy.min)
-                            continue;
-                        x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y2 = axisy.min;
-                    }
-
-                    // clip with ymax
-                    if (y1 >= y2 && y1 > axisy.max) {
-                        if (y2 > axisy.max)
-                            continue;
-                        x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y1 = axisy.max;
-                    }
-                    else if (y2 >= y1 && y2 > axisy.max) {
-                        if (y1 > axisy.max)
-                            continue;
-                        x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y2 = axisy.max;
-                    }
-
-                    // clip with xmin
-                    if (x1 <= x2 && x1 < axisx.min) {
-                        if (x2 < axisx.min)
-                            continue;
-                        y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x1 = axisx.min;
-                    }
-                    else if (x2 <= x1 && x2 < axisx.min) {
-                        if (x1 < axisx.min)
-                            continue;
-                        y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x2 = axisx.min;
-                    }
-
-                    // clip with xmax
-                    if (x1 >= x2 && x1 > axisx.max) {
-                        if (x2 > axisx.max)
-                            continue;
-                        y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x1 = axisx.max;
-                    }
-                    else if (x2 >= x1 && x2 > axisx.max) {
-                        if (x1 > axisx.max)
-                            continue;
-                        y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x2 = axisx.max;
-                    }
-
-                    if (x1 != prevx || y1 != prevy)
-                        ctx.moveTo(axisx.p2c(x1) + xoffset, axisy.p2c(y1) + yoffset);
-
-                    prevx = x2;
-                    prevy = y2;
-                    ctx.lineTo(axisx.p2c(x2) + xoffset, axisy.p2c(y2) + yoffset);
-                }
-                ctx.stroke();
-            }
-
-            function plotLineArea(datapoints, axisx, axisy) {
-                var points = datapoints.points,
-                    ps = datapoints.pointsize,
-                    bottom = Math.min(Math.max(0, axisy.min), axisy.max),
-                    i = 0, top, areaOpen = false,
-                    ypos = 1, segmentStart = 0, segmentEnd = 0;
-
-                // we process each segment in two turns, first forward
-                // direction to sketch out top, then once we hit the
-                // end we go backwards to sketch the bottom
-                while (true) {
-                    if (ps > 0 && i > points.length + ps)
-                        break;
-
-                    i += ps; // ps is negative if going backwards
-
-                    var x1 = points[i - ps],
-                        y1 = points[i - ps + ypos],
-                        x2 = points[i], y2 = points[i + ypos];
-
-                    if (areaOpen) {
-                        if (ps > 0 && x1 != null && x2 == null) {
-                            // at turning point
-                            segmentEnd = i;
-                            ps = -ps;
-                            ypos = 2;
-                            continue;
-                        }
-
-                        if (ps < 0 && i == segmentStart + ps) {
-                            // done with the reverse sweep
-                            ctx.fill();
-                            areaOpen = false;
-                            ps = -ps;
-                            ypos = 1;
-                            i = segmentStart = segmentEnd + ps;
-                            continue;
-                        }
-                    }
-
-                    if (x1 == null || x2 == null)
-                        continue;
-
-                    // clip x values
-
-                    // clip with xmin
-                    if (x1 <= x2 && x1 < axisx.min) {
-                        if (x2 < axisx.min)
-                            continue;
-                        y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x1 = axisx.min;
-                    }
-                    else if (x2 <= x1 && x2 < axisx.min) {
-                        if (x1 < axisx.min)
-                            continue;
-                        y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x2 = axisx.min;
-                    }
-
-                    // clip with xmax
-                    if (x1 >= x2 && x1 > axisx.max) {
-                        if (x2 > axisx.max)
-                            continue;
-                        y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x1 = axisx.max;
-                    }
-                    else if (x2 >= x1 && x2 > axisx.max) {
-                        if (x1 > axisx.max)
-                            continue;
-                        y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
-                        x2 = axisx.max;
-                    }
-
-                    if (!areaOpen) {
-                        // open area
-                        ctx.beginPath();
-                        ctx.moveTo(axisx.p2c(x1), axisy.p2c(bottom));
-                        areaOpen = true;
-                    }
-
-                    // now first check the case where both is outside
-                    if (y1 >= axisy.max && y2 >= axisy.max) {
-                        ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.max));
-                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.max));
-                        continue;
-                    }
-                    else if (y1 <= axisy.min && y2 <= axisy.min) {
-                        ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.min));
-                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.min));
-                        continue;
-                    }
-
-                    // else it's a bit more complicated, there might
-                    // be a flat maxed out rectangle first, then a
-                    // triangular cutout or reverse; to find these
-                    // keep track of the current x values
-                    var x1old = x1, x2old = x2;
-
-                    // clip the y values, without shortcutting, we
-                    // go through all cases in turn
-
-                    // clip with ymin
-                    if (y1 <= y2 && y1 < axisy.min && y2 >= axisy.min) {
-                        x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y1 = axisy.min;
-                    }
-                    else if (y2 <= y1 && y2 < axisy.min && y1 >= axisy.min) {
-                        x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y2 = axisy.min;
-                    }
-
-                    // clip with ymax
-                    if (y1 >= y2 && y1 > axisy.max && y2 <= axisy.max) {
-                        x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y1 = axisy.max;
-                    }
-                    else if (y2 >= y1 && y2 > axisy.max && y1 <= axisy.max) {
-                        x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
-                        y2 = axisy.max;
-                    }
-
-                    // if the x value was changed we got a rectangle
-                    // to fill
-                    if (x1 != x1old) {
-                        ctx.lineTo(axisx.p2c(x1old), axisy.p2c(y1));
-                        // it goes to (x1, y1), but we fill that below
-                    }
-
-                    // fill triangular section, this sometimes result
-                    // in redundant points if (x1, y1) hasn't changed
-                    // from previous line to, but we just ignore that
-                    ctx.lineTo(axisx.p2c(x1), axisy.p2c(y1));
-                    ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
-
-                    // fill the other rectangle if it's there
-                    if (x2 != x2old) {
-                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
-                        ctx.lineTo(axisx.p2c(x2old), axisy.p2c(y2));
-                    }
-                }
-            }
-
-            ctx.save();
-            ctx.translate(plotOffset.left, plotOffset.top);
-            ctx.lineJoin = "round";
-
-            var lw = series.lines.lineWidth,
-                sw = series.shadowSize;
-            // FIXME: consider another form of shadow when filling is turned on
-            if (lw > 0 && sw > 0) {
-                // draw shadow as a thick and thin line with transparency
-                ctx.lineWidth = sw;
-                ctx.strokeStyle = "rgba(0,0,0,0.1)";
-                // position shadow at angle from the mid of line
-                var angle = Math.PI/18;
-                plotLine(series.datapoints, Math.sin(angle) * (lw/2 + sw/2), Math.cos(angle) * (lw/2 + sw/2), series.xaxis, series.yaxis);
-                ctx.lineWidth = sw/2;
-                plotLine(series.datapoints, Math.sin(angle) * (lw/2 + sw/4), Math.cos(angle) * (lw/2 + sw/4), series.xaxis, series.yaxis);
-            }
-
-            ctx.lineWidth = lw;
-            ctx.strokeStyle = series.color;
-            var fillStyle = getFillStyle(series.lines, series.color, 0, plotHeight);
-            if (fillStyle) {
-                ctx.fillStyle = fillStyle;
-                plotLineArea(series.datapoints, series.xaxis, series.yaxis);
-            }
-
-            if (lw > 0)
-                plotLine(series.datapoints, 0, 0, series.xaxis, series.yaxis);
-            ctx.restore();
-        }
-
-        function drawSeriesPoints(series) {
-            function plotPoints(datapoints, radius, fillStyle, offset, shadow, axisx, axisy, symbol) {
-                var points = datapoints.points, ps = datapoints.pointsize;
-
-                for (var i = 0; i < points.length; i += ps) {
-                    var x = points[i], y = points[i + 1];
-                    if (x == null || x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max)
-                        continue;
-
-                    ctx.beginPath();
-                    x = axisx.p2c(x);
-                    y = axisy.p2c(y) + offset;
-                    if (symbol == "circle")
-                        ctx.arc(x, y, radius, 0, shadow ? Math.PI : Math.PI * 2, false);
-                    else
-                        symbol(ctx, x, y, radius, shadow);
-                    ctx.closePath();
-
-                    if (fillStyle) {
-                        ctx.fillStyle = fillStyle;
-                        ctx.fill();
-                    }
-                    ctx.stroke();
-                }
-            }
-
-            ctx.save();
-            ctx.translate(plotOffset.left, plotOffset.top);
-
-            var lw = series.points.lineWidth,
-                sw = series.shadowSize,
-                radius = series.points.radius,
-                symbol = series.points.symbol;
-
-            // If the user sets the line width to 0, we change it to a very 
-            // small value. A line width of 0 seems to force the default of 1.
-            // Doing the conditional here allows the shadow setting to still be 
-            // optional even with a lineWidth of 0.
-
-            if( lw == 0 )
-                lw = 0.0001;
-
-            if (lw > 0 && sw > 0) {
-                // draw shadow in two steps
-                var w = sw / 2;
-                ctx.lineWidth = w;
-                ctx.strokeStyle = "rgba(0,0,0,0.1)";
-                plotPoints(series.datapoints, radius, null, w + w/2, true,
-                           series.xaxis, series.yaxis, symbol);
-
-                ctx.strokeStyle = "rgba(0,0,0,0.2)";
-                plotPoints(series.datapoints, radius, null, w/2, true,
-                           series.xaxis, series.yaxis, symbol);
-            }
-
-            ctx.lineWidth = lw;
-            ctx.strokeStyle = series.color;
-            plotPoints(series.datapoints, radius,
-                       getFillStyle(series.points, series.color), 0, false,
-                       series.xaxis, series.yaxis, symbol);
-            ctx.restore();
-        }
-
-        function drawBar(x, y, b, barLeft, barRight, fillStyleCallback, axisx, axisy, c, horizontal, lineWidth) {
-            var left, right, bottom, top,
-                drawLeft, drawRight, drawTop, drawBottom,
-                tmp;
-
-            // in horizontal mode, we start the bar from the left
-            // instead of from the bottom so it appears to be
-            // horizontal rather than vertical
-            if (horizontal) {
-                drawBottom = drawRight = drawTop = true;
-                drawLeft = false;
-                left = b;
-                right = x;
-                top = y + barLeft;
-                bottom = y + barRight;
-
-                // account for negative bars
-                if (right < left) {
-                    tmp = right;
-                    right = left;
-                    left = tmp;
-                    drawLeft = true;
-                    drawRight = false;
-                }
-            }
-            else {
-                drawLeft = drawRight = drawTop = true;
-                drawBottom = false;
-                left = x + barLeft;
-                right = x + barRight;
-                bottom = b;
-                top = y;
-
-                // account for negative bars
-                if (top < bottom) {
-                    tmp = top;
-                    top = bottom;
-                    bottom = tmp;
-                    drawBottom = true;
-                    drawTop = false;
-                }
-            }
-
-            // clip
-            if (right < axisx.min || left > axisx.max ||
-                top < axisy.min || bottom > axisy.max)
-                return;
-
-            if (left < axisx.min) {
-                left = axisx.min;
-                drawLeft = false;
-            }
-
-            if (right > axisx.max) {
-                right = axisx.max;
-                drawRight = false;
-            }
-
-            if (bottom < axisy.min) {
-                bottom = axisy.min;
-                drawBottom = false;
-            }
-
-            if (top > axisy.max) {
-                top = axisy.max;
-                drawTop = false;
-            }
-
-            left = axisx.p2c(left);
-            bottom = axisy.p2c(bottom);
-            right = axisx.p2c(right);
-            top = axisy.p2c(top);
-
-            // fill the bar
-            if (fillStyleCallback) {
-                c.fillStyle = fillStyleCallback(bottom, top);
-                c.fillRect(left, top, right - left, bottom - top)
-            }
-
-            // draw outline
-            if (lineWidth > 0 && (drawLeft || drawRight || drawTop || drawBottom)) {
-                c.beginPath();
-
-                // FIXME: inline moveTo is buggy with excanvas
-                c.moveTo(left, bottom);
-                if (drawLeft)
-                    c.lineTo(left, top);
-                else
-                    c.moveTo(left, top);
-                if (drawTop)
-                    c.lineTo(right, top);
-                else
-                    c.moveTo(right, top);
-                if (drawRight)
-                    c.lineTo(right, bottom);
-                else
-                    c.moveTo(right, bottom);
-                if (drawBottom)
-                    c.lineTo(left, bottom);
-                else
-                    c.moveTo(left, bottom);
-                c.stroke();
-            }
-        }
-
-        function drawSeriesBars(series) {
-            function plotBars(datapoints, barLeft, barRight, fillStyleCallback, axisx, axisy) {
-                var points = datapoints.points, ps = datapoints.pointsize;
-
-                for (var i = 0; i < points.length; i += ps) {
-                    if (points[i] == null)
-                        continue;
-                    drawBar(points[i], points[i + 1], points[i + 2], barLeft, barRight, fillStyleCallback, axisx, axisy, ctx, series.bars.horizontal, series.bars.lineWidth);
-                }
-            }
-
-            ctx.save();
-            ctx.translate(plotOffset.left, plotOffset.top);
-
-            // FIXME: figure out a way to add shadows (for instance along the right edge)
-            ctx.lineWidth = series.bars.lineWidth;
-            ctx.strokeStyle = series.color;
-
-            var barLeft;
-
-            switch (series.bars.align) {
-                case "left":
-                    barLeft = 0;
-                    break;
-                case "right":
-                    barLeft = -series.bars.barWidth;
-                    break;
-                default:
-                    barLeft = -series.bars.barWidth / 2;
-            }
-
-            var fillStyleCallback = series.bars.fill ? function (bottom, top) { return getFillStyle(series.bars, series.color, bottom, top); } : null;
-            plotBars(series.datapoints, barLeft, barLeft + series.bars.barWidth, fillStyleCallback, series.xaxis, series.yaxis);
-            ctx.restore();
-        }
-
-        function getFillStyle(filloptions, seriesColor, bottom, top) {
-            var fill = filloptions.fill;
-            if (!fill)
-                return null;
-
-            if (filloptions.fillColor)
-                return getColorOrGradient(filloptions.fillColor, bottom, top, seriesColor);
-
-            var c = $.color.parse(seriesColor);
-            c.a = typeof fill == "number" ? fill : 0.4;
-            c.normalize();
-            return c.toString();
-        }
-
-        function insertLegend() {
-
-            if (options.legend.container != null) {
-                $(options.legend.container).html("");
-            } else {
-                placeholder.find(".legend").remove();
-            }
-
-            if (!options.legend.show) {
-                return;
-            }
-
-            var fragments = [], entries = [], rowStarted = false,
-                lf = options.legend.labelFormatter, s, label;
-
-            // Build a list of legend entries, with each having a label and a color
-
-            for (var i = 0; i < series.length; ++i) {
-                s = series[i];
-                if (s.label) {
-                    label = lf ? lf(s.label, s) : s.label;
-                    if (label) {
-                        entries.push({
-                            label: label,
-                            color: s.color
-                        });
-                    }
-                }
-            }
-
-            // Sort the legend using either the default or a custom comparator
-
-            if (options.legend.sorted) {
-                if ($.isFunction(options.legend.sorted)) {
-                    entries.sort(options.legend.sorted);
-                } else if (options.legend.sorted == "reverse") {
-                	entries.reverse();
-                } else {
-                    var ascending = options.legend.sorted != "descending";
-                    entries.sort(function(a, b) {
-                        return a.label == b.label ? 0 : (
-                            (a.label < b.label) != ascending ? 1 : -1   // Logical XOR
-                        );
-                    });
-                }
-            }
-
-            // Generate markup for the list of entries, in their final order
-
-            for (var i = 0; i < entries.length; ++i) {
-
-                var entry = entries[i];
-
-                if (i % options.legend.noColumns == 0) {
-                    if (rowStarted)
-                        fragments.push('</tr>');
-                    fragments.push('<tr>');
-                    rowStarted = true;
-                }
-
-                fragments.push(
-                    '<td class="legendColorBox"><div style="border:1px solid ' + options.legend.labelBoxBorderColor + ';padding:1px"><div style="width:4px;height:0;border:5px solid ' + entry.color + ';overflow:hidden"></div></div></td>' +
-                    '<td class="legendLabel">' + entry.label + '</td>'
-                );
-            }
-
-            if (rowStarted)
-                fragments.push('</tr>');
-
-            if (fragments.length == 0)
-                return;
-
-            var table = '<table style="font-size:smaller;color:' + options.grid.color + '">' + fragments.join("") + '</table>';
-            if (options.legend.container != null)
-                $(options.legend.container).html(table);
-            else {
-                var pos = "",
-                    p = options.legend.position,
-                    m = options.legend.margin;
-                if (m[0] == null)
-                    m = [m, m];
-                if (p.charAt(0) == "n")
-                    pos += 'top:' + (m[1] + plotOffset.top) + 'px;';
-                else if (p.charAt(0) == "s")
-                    pos += 'bottom:' + (m[1] + plotOffset.bottom) + 'px;';
-                if (p.charAt(1) == "e")
-                    pos += 'right:' + (m[0] + plotOffset.right) + 'px;';
-                else if (p.charAt(1) == "w")
-                    pos += 'left:' + (m[0] + plotOffset.left) + 'px;';
-                var legend = $('<div class="legend">' + table.replace('style="', 'style="position:absolute;' + pos +';') + '</div>').appendTo(placeholder);
-                if (options.legend.backgroundOpacity != 0.0) {
-                    // put in the transparent background
-                    // separately to avoid blended labels and
-                    // label boxes
-                    var c = options.legend.backgroundColor;
-                    if (c == null) {
-                        c = options.grid.backgroundColor;
-                        if (c && typeof c == "string")
-                            c = $.color.parse(c);
-                        else
-                            c = $.color.extract(legend, 'background-color');
-                        c.a = 1;
-                        c = c.toString();
-                    }
-                    var div = legend.children();
-                    $('<div style="position:absolute;width:' + div.width() + 'px;height:' + div.height() + 'px;' + pos +'background-color:' + c + ';"> </div>').prependTo(legend).css('opacity', options.legend.backgroundOpacity);
-                }
-            }
-        }
-
-
-        // interactive features
-
-        var highlights = [],
-            redrawTimeout = null;
-
-        // returns the data item the mouse is over, or null if none is found
-        function findNearbyItem(mouseX, mouseY, seriesFilter) {
-            var maxDistance = options.grid.mouseActiveRadius,
-                smallestDistance = maxDistance * maxDistance + 1,
-                item = null, foundPoint = false, i, j, ps;
-
-            for (i = series.length - 1; i >= 0; --i) {
-                if (!seriesFilter(series[i]))
-                    continue;
-
-                var s = series[i],
-                    axisx = s.xaxis,
-                    axisy = s.yaxis,
-                    points = s.datapoints.points,
-                    mx = axisx.c2p(mouseX), // precompute some stuff to make the loop faster
-                    my = axisy.c2p(mouseY),
-                    maxx = maxDistance / axisx.scale,
-                    maxy = maxDistance / axisy.scale;
-
-                ps = s.datapoints.pointsize;
-                // with inverse transforms, we can't use the maxx/maxy
-                // optimization, sadly
-                if (axisx.options.inverseTransform)
-                    maxx = Number.MAX_VALUE;
-                if (axisy.options.inverseTransform)
-                    maxy = Number.MAX_VALUE;
-
-                if (s.lines.show || s.points.show) {
-                    for (j = 0; j < points.length; j += ps) {
-                        var x = points[j], y = points[j + 1];
-                        if (x == null)
-                            continue;
-
-                        // For points and lines, the cursor must be within a
-                        // certain distance to the data point
-                        if (x - mx > maxx || x - mx < -maxx ||
-                            y - my > maxy || y - my < -maxy)
-                            continue;
-
-                        // We have to calculate distances in pixels, not in
-                        // data units, because the scales of the axes may be different
-                        var dx = Math.abs(axisx.p2c(x) - mouseX),
-                            dy = Math.abs(axisy.p2c(y) - mouseY),
-                            dist = dx * dx + dy * dy; // we save the sqrt
-
-                        // use <= to ensure last point takes precedence
-                        // (last generally means on top of)
-                        if (dist < smallestDistance) {
-                            smallestDistance = dist;
-                            item = [i, j / ps];
-                        }
-                    }
-                }
-
-                if (s.bars.show && !item) { // no other point can be nearby
-
-                    var barLeft, barRight;
-
-                    switch (s.bars.align) {
-                        case "left":
-                            barLeft = 0;
-                            break;
-                        case "right":
-                            barLeft = -s.bars.barWidth;
-                            break;
-                        default:
-                            barLeft = -s.bars.barWidth / 2;
-                    }
-
-                    barRight = barLeft + s.bars.barWidth;
-
-                    for (j = 0; j < points.length; j += ps) {
-                        var x = points[j], y = points[j + 1], b = points[j + 2];
-                        if (x == null)
-                            continue;
-
-                        // for a bar graph, the cursor must be inside the bar
-                        if (series[i].bars.horizontal ?
-                            (mx <= Math.max(b, x) && mx >= Math.min(b, x) &&
-                             my >= y + barLeft && my <= y + barRight) :
-                            (mx >= x + barLeft && mx <= x + barRight &&
-                             my >= Math.min(b, y) && my <= Math.max(b, y)))
-                                item = [i, j / ps];
-                    }
-                }
-            }
-
-            if (item) {
-                i = item[0];
-                j = item[1];
-                ps = series[i].datapoints.pointsize;
-
-                return { datapoint: series[i].datapoints.points.slice(j * ps, (j + 1) * ps),
-                         dataIndex: j,
-                         series: series[i],
-                         seriesIndex: i };
-            }
-
-            return null;
-        }
-
-        function onMouseMove(e) {
-            if (options.grid.hoverable)
-                triggerClickHoverEvent("plothover", e,
-                                       function (s) { return s["hoverable"] != false; });
-        }
-
-        function onMouseLeave(e) {
-            if (options.grid.hoverable)
-                triggerClickHoverEvent("plothover", e,
-                                       function (s) { return false; });
-        }
-
-        function onClick(e) {
-            triggerClickHoverEvent("plotclick", e,
-                                   function (s) { return s["clickable"] != false; });
-        }
-
-        // trigger click or hover event (they send the same parameters
-        // so we share their code)
-        function triggerClickHoverEvent(eventname, event, seriesFilter) {
-            var offset = eventHolder.offset(),
-                canvasX = event.pageX - offset.left - plotOffset.left,
-                canvasY = event.pageY - offset.top - plotOffset.top,
-            pos = canvasToAxisCoords({ left: canvasX, top: canvasY });
-
-            pos.pageX = event.pageX;
-            pos.pageY = event.pageY;
-
-            var item = findNearbyItem(canvasX, canvasY, seriesFilter);
-
-            if (item) {
-                // fill in mouse pos for any listeners out there
-                item.pageX = parseInt(item.series.xaxis.p2c(item.datapoint[0]) + offset.left + plotOffset.left, 10);
-                item.pageY = parseInt(item.series.yaxis.p2c(item.datapoint[1]) + offset.top + plotOffset.top, 10);
-            }
-
-            if (options.grid.autoHighlight) {
-                // clear auto-highlights
-                for (var i = 0; i < highlights.length; ++i) {
-                    var h = highlights[i];
-                    if (h.auto == eventname &&
-                        !(item && h.series == item.series &&
-                          h.point[0] == item.datapoint[0] &&
-                          h.point[1] == item.datapoint[1]))
-                        unhighlight(h.series, h.point);
-                }
-
-                if (item)
-                    highlight(item.series, item.datapoint, eventname);
-            }
-
-            placeholder.trigger(eventname, [ pos, item ]);
-        }
-
-        function triggerRedrawOverlay() {
-            var t = options.interaction.redrawOverlayInterval;
-            if (t == -1) {      // skip event queue
-                drawOverlay();
-                return;
-            }
-
-            if (!redrawTimeout)
-                redrawTimeout = setTimeout(drawOverlay, t);
-        }
-
-        function drawOverlay() {
-            redrawTimeout = null;
-
-            // draw highlights
-            octx.save();
-            overlay.clear();
-            octx.translate(plotOffset.left, plotOffset.top);
-
-            var i, hi;
-            for (i = 0; i < highlights.length; ++i) {
-                hi = highlights[i];
-
-                if (hi.series.bars.show)
-                    drawBarHighlight(hi.series, hi.point);
-                else
-                    drawPointHighlight(hi.series, hi.point);
-            }
-            octx.restore();
-
-            executeHooks(hooks.drawOverlay, [octx]);
-        }
-
-        function highlight(s, point, auto) {
-            if (typeof s == "number")
-                s = series[s];
-
-            if (typeof point == "number") {
-                var ps = s.datapoints.pointsize;
-                point = s.datapoints.points.slice(ps * point, ps * (point + 1));
-            }
-
-            var i = indexOfHighlight(s, point);
-            if (i == -1) {
-                highlights.push({ series: s, point: point, auto: auto });
-
-                triggerRedrawOverlay();
-            }
-            else if (!auto)
-                highlights[i].auto = false;
-        }
-
-        function unhighlight(s, point) {
-            if (s == null && point == null) {
-                highlights = [];
-                triggerRedrawOverlay();
-                return;
-            }
-
-            if (typeof s == "number")
-                s = series[s];
-
-            if (typeof point == "number") {
-                var ps = s.datapoints.pointsize;
-                point = s.datapoints.points.slice(ps * point, ps * (point + 1));
-            }
-
-            var i = indexOfHighlight(s, point);
-            if (i != -1) {
-                highlights.splice(i, 1);
-
-                triggerRedrawOverlay();
-            }
-        }
-
-        function indexOfHighlight(s, p) {
-            for (var i = 0; i < highlights.length; ++i) {
-                var h = highlights[i];
-                if (h.series == s && h.point[0] == p[0]
-                    && h.point[1] == p[1])
-                    return i;
-            }
-            return -1;
-        }
-
-        function drawPointHighlight(series, point) {
-            var x = point[0], y = point[1],
-                axisx = series.xaxis, axisy = series.yaxis,
-                highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString();
-
-            if (x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max)
-                return;
-
-            var pointRadius = series.points.radius + series.points.lineWidth / 2;
-            octx.lineWidth = pointRadius;
-            octx.strokeStyle = highlightColor;
-            var radius = 1.5 * pointRadius;
-            x = axisx.p2c(x);
-            y = axisy.p2c(y);
-
-            octx.beginPath();
-            if (series.points.symbol == "circle")
-                octx.arc(x, y, radius, 0, 2 * Math.PI, false);
-            else
-                series.points.symbol(octx, x, y, radius, false);
-            octx.closePath();
-            octx.stroke();
-        }
-
-        function drawBarHighlight(series, point) {
-            var highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString(),
-                fillStyle = highlightColor,
-                barLeft;
-
-            switch (series.bars.align) {
-                case "left":
-                    barLeft = 0;
-                    break;
-                case "right":
-                    barLeft = -series.bars.barWidth;
-                    break;
-                default:
-                    barLeft = -series.bars.barWidth / 2;
-            }
-
-            octx.lineWidth = series.bars.lineWidth;
-            octx.strokeStyle = highlightColor;
-
-            drawBar(point[0], point[1], point[2] || 0, barLeft, barLeft + series.bars.barWidth,
-                    function () { return fillStyle; }, series.xaxis, series.yaxis, octx, series.bars.horizontal, series.bars.lineWidth);
-        }
-
-        function getColorOrGradient(spec, bottom, top, defaultColor) {
-            if (typeof spec == "string")
-                return spec;
-            else {
-                // assume this is a gradient spec; IE currently only
-                // supports a simple vertical gradient properly, so that's
-                // what we support too
-                var gradient = ctx.createLinearGradient(0, top, 0, bottom);
-
-                for (var i = 0, l = spec.colors.length; i < l; ++i) {
-                    var c = spec.colors[i];
-                    if (typeof c != "string") {
-                        var co = $.color.parse(defaultColor);
-                        if (c.brightness != null)
-                            co = co.scale('rgb', c.brightness);
-                        if (c.opacity != null)
-                            co.a *= c.opacity;
-                        c = co.toString();
-                    }
-                    gradient.addColorStop(i / (l - 1), c);
-                }
-
-                return gradient;
-            }
-        }
-    }
-
-    // Add the plot function to the top level of the jQuery object
-
-    $.plot = function(placeholder, data, options) {
-        //var t0 = new Date();
-        var plot = new Plot($(placeholder), data, options, $.plot.plugins);
-        //(window.console ? console.log : alert)("time used (msecs): " + ((new Date()).getTime() - t0.getTime()));
-        return plot;
-    };
-
-    $.plot.version = "0.8.3";
-
-    $.plot.plugins = [];
-
-    // Also add the plot function as a chainable property
-
-    $.fn.plot = function(data, options) {
-        return this.each(function() {
-            $.plot(this, data, options);
-        });
-    };
-
-    // round to nearby lower multiple of base
-    function floorInBase(n, base) {
-        return base * Math.floor(n / base);
-    }
-
-})(jQuery);

rhodecode/public/js/jquery.flot.selection.js

@@ -1,360 +0,0 b''
-/* Flot plugin for selecting regions of a plot.
-
-Copyright (c) 2007-2014 IOLA and Ole Laursen.
-Licensed under the MIT license.
-
-The plugin supports these options:
-
-selection: {
-	mode: null or "x" or "y" or "xy",
-	color: color,
-	shape: "round" or "miter" or "bevel",
-	minSize: number of pixels
-}
-
-Selection support is enabled by setting the mode to one of "x", "y" or "xy".
-In "x" mode, the user will only be able to specify the x range, similarly for
-"y" mode. For "xy", the selection becomes a rectangle where both ranges can be
-specified. "color" is color of the selection (if you need to change the color
-later on, you can get to it with plot.getOptions().selection.color). "shape"
-is the shape of the corners of the selection.
-
-"minSize" is the minimum size a selection can be in pixels. This value can
-be customized to determine the smallest size a selection can be and still
-have the selection rectangle be displayed. When customizing this value, the
-fact that it refers to pixels, not axis units must be taken into account.
-Thus, for example, if there is a bar graph in time mode with BarWidth set to 1
-minute, setting "minSize" to 1 will not make the minimum selection size 1
-minute, but rather 1 pixel. Note also that setting "minSize" to 0 will prevent
-"plotunselected" events from being fired when the user clicks the mouse without
-dragging.
-
-When selection support is enabled, a "plotselected" event will be emitted on
-the DOM element you passed into the plot function. The event handler gets a
-parameter with the ranges selected on the axes, like this:
-
-	placeholder.bind( "plotselected", function( event, ranges ) {
-		alert("You selected " + ranges.xaxis.from + " to " + ranges.xaxis.to)
-		// similar for yaxis - with multiple axes, the extra ones are in
-		// x2axis, x3axis, ...
-	});
-
-The "plotselected" event is only fired when the user has finished making the
-selection. A "plotselecting" event is fired during the process with the same
-parameters as the "plotselected" event, in case you want to know what's
-happening while it's happening,
-
-A "plotunselected" event with no arguments is emitted when the user clicks the
-mouse to remove the selection. As stated above, setting "minSize" to 0 will
-destroy this behavior.
-
-The plugin allso adds the following methods to the plot object:
-
-- setSelection( ranges, preventEvent )
-
-  Set the selection rectangle. The passed in ranges is on the same form as
-  returned in the "plotselected" event. If the selection mode is "x", you
-  should put in either an xaxis range, if the mode is "y" you need to put in
-  an yaxis range and both xaxis and yaxis if the selection mode is "xy", like
-  this:
-
-	setSelection({ xaxis: { from: 0, to: 10 }, yaxis: { from: 40, to: 60 } });
-
-  setSelection will trigger the "plotselected" event when called. If you don't
-  want that to happen, e.g. if you're inside a "plotselected" handler, pass
-  true as the second parameter. If you are using multiple axes, you can
-  specify the ranges on any of those, e.g. as x2axis/x3axis/... instead of
-  xaxis, the plugin picks the first one it sees.
-
-- clearSelection( preventEvent )
-
-  Clear the selection rectangle. Pass in true to avoid getting a
-  "plotunselected" event.
-
-- getSelection()
-
-  Returns the current selection in the same format as the "plotselected"
-  event. If there's currently no selection, the function returns null.
-
-*/
-
-(function ($) {
-    function init(plot) {
-        var selection = {
-                first: { x: -1, y: -1}, second: { x: -1, y: -1},
-                show: false,
-                active: false
-            };
-
-        // FIXME: The drag handling implemented here should be
-        // abstracted out, there's some similar code from a library in
-        // the navigation plugin, this should be massaged a bit to fit
-        // the Flot cases here better and reused. Doing this would
-        // make this plugin much slimmer.
-        var savedhandlers = {};
-
-        var mouseUpHandler = null;
-        
-        function onMouseMove(e) {
-            if (selection.active) {
-                updateSelection(e);
-                
-                plot.getPlaceholder().trigger("plotselecting", [ getSelection() ]);
-            }
-        }
-
-        function onMouseDown(e) {
-            if (e.which != 1)  // only accept left-click
-                return;
-            
-            // cancel out any text selections
-            document.body.focus();
-
-            // prevent text selection and drag in old-school browsers
-            if (document.onselectstart !== undefined && savedhandlers.onselectstart == null) {
-                savedhandlers.onselectstart = document.onselectstart;
-                document.onselectstart = function () { return false; };
-            }
-            if (document.ondrag !== undefined && savedhandlers.ondrag == null) {
-                savedhandlers.ondrag = document.ondrag;
-                document.ondrag = function () { return false; };
-            }
-
-            setSelectionPos(selection.first, e);
-
-            selection.active = true;
-
-            // this is a bit silly, but we have to use a closure to be
-            // able to whack the same handler again
-            mouseUpHandler = function (e) { onMouseUp(e); };
-            
-            $(document).one("mouseup", mouseUpHandler);
-        }
-
-        function onMouseUp(e) {
-            mouseUpHandler = null;
-            
-            // revert drag stuff for old-school browsers
-            if (document.onselectstart !== undefined)
-                document.onselectstart = savedhandlers.onselectstart;
-            if (document.ondrag !== undefined)
-                document.ondrag = savedhandlers.ondrag;
-
-            // no more dragging
-            selection.active = false;
-            updateSelection(e);
-
-            if (selectionIsSane())
-                triggerSelectedEvent();
-            else {
-                // this counts as a clear
-                plot.getPlaceholder().trigger("plotunselected", [ ]);
-                plot.getPlaceholder().trigger("plotselecting", [ null ]);
-            }
-
-            return false;
-        }
-
-        function getSelection() {
-            if (!selectionIsSane())
-                return null;
-            
-            if (!selection.show) return null;
-
-            var r = {}, c1 = selection.first, c2 = selection.second;
-            $.each(plot.getAxes(), function (name, axis) {
-                if (axis.used) {
-                    var p1 = axis.c2p(c1[axis.direction]), p2 = axis.c2p(c2[axis.direction]); 
-                    r[name] = { from: Math.min(p1, p2), to: Math.max(p1, p2) };
-                }
-            });
-            return r;
-        }
-
-        function triggerSelectedEvent() {
-            var r = getSelection();
-
-            plot.getPlaceholder().trigger("plotselected", [ r ]);
-
-            // backwards-compat stuff, to be removed in future
-            if (r.xaxis && r.yaxis)
-                plot.getPlaceholder().trigger("selected", [ { x1: r.xaxis.from, y1: r.yaxis.from, x2: r.xaxis.to, y2: r.yaxis.to } ]);
-        }
-
-        function clamp(min, value, max) {
-            return value < min ? min: (value > max ? max: value);
-        }
-
-        function setSelectionPos(pos, e) {
-            var o = plot.getOptions();
-            var offset = plot.getPlaceholder().offset();
-            var plotOffset = plot.getPlotOffset();
-            pos.x = clamp(0, e.pageX - offset.left - plotOffset.left, plot.width());
-            pos.y = clamp(0, e.pageY - offset.top - plotOffset.top, plot.height());
-
-            if (o.selection.mode == "y")
-                pos.x = pos == selection.first ? 0 : plot.width();
-
-            if (o.selection.mode == "x")
-                pos.y = pos == selection.first ? 0 : plot.height();
-        }
-
-        function updateSelection(pos) {
-            if (pos.pageX == null)
-                return;
-
-            setSelectionPos(selection.second, pos);
-            if (selectionIsSane()) {
-                selection.show = true;
-                plot.triggerRedrawOverlay();
-            }
-            else
-                clearSelection(true);
-        }
-
-        function clearSelection(preventEvent) {
-            if (selection.show) {
-                selection.show = false;
-                plot.triggerRedrawOverlay();
-                if (!preventEvent)
-                    plot.getPlaceholder().trigger("plotunselected", [ ]);
-            }
-        }
-
-        // function taken from markings support in Flot
-        function extractRange(ranges, coord) {
-            var axis, from, to, key, axes = plot.getAxes();
-
-            for (var k in axes) {
-                axis = axes[k];
-                if (axis.direction == coord) {
-                    key = coord + axis.n + "axis";
-                    if (!ranges[key] && axis.n == 1)
-                        key = coord + "axis"; // support x1axis as xaxis
-                    if (ranges[key]) {
-                        from = ranges[key].from;
-                        to = ranges[key].to;
-                        break;
-                    }
-                }
-            }
-
-            // backwards-compat stuff - to be removed in future
-            if (!ranges[key]) {
-                axis = coord == "x" ? plot.getXAxes()[0] : plot.getYAxes()[0];
-                from = ranges[coord + "1"];
-                to = ranges[coord + "2"];
-            }
-
-            // auto-reverse as an added bonus
-            if (from != null && to != null && from > to) {
-                var tmp = from;
-                from = to;
-                to = tmp;
-            }
-            
-            return { from: from, to: to, axis: axis };
-        }
-        
-        function setSelection(ranges, preventEvent) {
-            var axis, range, o = plot.getOptions();
-
-            if (o.selection.mode == "y") {
-                selection.first.x = 0;
-                selection.second.x = plot.width();
-            }
-            else {
-                range = extractRange(ranges, "x");
-
-                selection.first.x = range.axis.p2c(range.from);
-                selection.second.x = range.axis.p2c(range.to);
-            }
-
-            if (o.selection.mode == "x") {
-                selection.first.y = 0;
-                selection.second.y = plot.height();
-            }
-            else {
-                range = extractRange(ranges, "y");
-
-                selection.first.y = range.axis.p2c(range.from);
-                selection.second.y = range.axis.p2c(range.to);
-            }
-
-            selection.show = true;
-            plot.triggerRedrawOverlay();
-            if (!preventEvent && selectionIsSane())
-                triggerSelectedEvent();
-        }
-
-        function selectionIsSane() {
-            var minSize = plot.getOptions().selection.minSize;
-            return Math.abs(selection.second.x - selection.first.x) >= minSize &&
-                Math.abs(selection.second.y - selection.first.y) >= minSize;
-        }
-
-        plot.clearSelection = clearSelection;
-        plot.setSelection = setSelection;
-        plot.getSelection = getSelection;
-
-        plot.hooks.bindEvents.push(function(plot, eventHolder) {
-            var o = plot.getOptions();
-            if (o.selection.mode != null) {
-                eventHolder.mousemove(onMouseMove);
-                eventHolder.mousedown(onMouseDown);
-            }
-        });
-
-
-        plot.hooks.drawOverlay.push(function (plot, ctx) {
-            // draw selection
-            if (selection.show && selectionIsSane()) {
-                var plotOffset = plot.getPlotOffset();
-                var o = plot.getOptions();
-
-                ctx.save();
-                ctx.translate(plotOffset.left, plotOffset.top);
-
-                var c = $.color.parse(o.selection.color);
-
-                ctx.strokeStyle = c.scale('a', 0.8).toString();
-                ctx.lineWidth = 1;
-                ctx.lineJoin = o.selection.shape;
-                ctx.fillStyle = c.scale('a', 0.4).toString();
-
-                var x = Math.min(selection.first.x, selection.second.x) + 0.5,
-                    y = Math.min(selection.first.y, selection.second.y) + 0.5,
-                    w = Math.abs(selection.second.x - selection.first.x) - 1,
-                    h = Math.abs(selection.second.y - selection.first.y) - 1;
-
-                ctx.fillRect(x, y, w, h);
-                ctx.strokeRect(x, y, w, h);
-
-                ctx.restore();
-            }
-        });
-        
-        plot.hooks.shutdown.push(function (plot, eventHolder) {
-            eventHolder.unbind("mousemove", onMouseMove);
-            eventHolder.unbind("mousedown", onMouseDown);
-            
-            if (mouseUpHandler)
-                $(document).unbind("mouseup", mouseUpHandler);
-        });
-
-    }
-
-    $.plot.plugins.push({
-        init: init,
-        options: {
-            selection: {
-                mode: null, // one of null, "x", "y" or "xy"
-                color: "#e8cfac",
-                shape: "round", // one of "round", "miter", or "bevel"
-                minSize: 5 // minimum number of pixels
-            }
-        },
-        name: 'selection',
-        version: '1.1'
-    });
-})(jQuery);

rhodecode/public/js/jquery.flot.time.js

@@ -1,432 +0,0 b''
-/* Pretty handling of time axes.
-
-Copyright (c) 2007-2014 IOLA and Ole Laursen.
-Licensed under the MIT license.
-
-Set axis.mode to "time" to enable. See the section "Time series data" in
-API.txt for details.
-
-*/
-
-(function($) {
-
-	var options = {
-		xaxis: {
-			timezone: null,		// "browser" for local to the client or timezone for timezone-js
-			timeformat: null,	// format string to use
-			twelveHourClock: false,	// 12 or 24 time in time mode
-			monthNames: null	// list of names of months
-		}
-	};
-
-	// round to nearby lower multiple of base
-
-	function floorInBase(n, base) {
-		return base * Math.floor(n / base);
-	}
-
-	// Returns a string with the date d formatted according to fmt.
-	// A subset of the Open Group's strftime format is supported.
-
-	function formatDate(d, fmt, monthNames, dayNames) {
-
-		if (typeof d.strftime == "function") {
-			return d.strftime(fmt);
-		}
-
-		var leftPad = function(n, pad) {
-			n = "" + n;
-			pad = "" + (pad == null ? "0" : pad);
-			return n.length == 1 ? pad + n : n;
-		};
-
-		var r = [];
-		var escape = false;
-		var hours = d.getHours();
-		var isAM = hours < 12;
-
-		if (monthNames == null) {
-			monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-		}
-
-		if (dayNames == null) {
-			dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-		}
-
-		var hours12;
-
-		if (hours > 12) {
-			hours12 = hours - 12;
-		} else if (hours == 0) {
-			hours12 = 12;
-		} else {
-			hours12 = hours;
-		}
-
-		for (var i = 0; i < fmt.length; ++i) {
-
-			var c = fmt.charAt(i);
-
-			if (escape) {
-				switch (c) {
-					case 'a': c = "" + dayNames[d.getDay()]; break;
-					case 'b': c = "" + monthNames[d.getMonth()]; break;
-					case 'd': c = leftPad(d.getDate()); break;
-					case 'e': c = leftPad(d.getDate(), " "); break;
-					case 'h':	// For back-compat with 0.7; remove in 1.0
-					case 'H': c = leftPad(hours); break;
-					case 'I': c = leftPad(hours12); break;
-					case 'l': c = leftPad(hours12, " "); break;
-					case 'm': c = leftPad(d.getMonth() + 1); break;
-					case 'M': c = leftPad(d.getMinutes()); break;
-					// quarters not in Open Group's strftime specification
-					case 'q':
-						c = "" + (Math.floor(d.getMonth() / 3) + 1); break;
-					case 'S': c = leftPad(d.getSeconds()); break;
-					case 'y': c = leftPad(d.getFullYear() % 100); break;
-					case 'Y': c = "" + d.getFullYear(); break;
-					case 'p': c = (isAM) ? ("" + "am") : ("" + "pm"); break;
-					case 'P': c = (isAM) ? ("" + "AM") : ("" + "PM"); break;
-					case 'w': c = "" + d.getDay(); break;
-				}
-				r.push(c);
-				escape = false;
-			} else {
-				if (c == "%") {
-					escape = true;
-				} else {
-					r.push(c);
-				}
-			}
-		}
-
-		return r.join("");
-	}
-
-	// To have a consistent view of time-based data independent of which time
-	// zone the client happens to be in we need a date-like object independent
-	// of time zones.  This is done through a wrapper that only calls the UTC
-	// versions of the accessor methods.
-
-	function makeUtcWrapper(d) {
-
-		function addProxyMethod(sourceObj, sourceMethod, targetObj, targetMethod) {
-			sourceObj[sourceMethod] = function() {
-				return targetObj[targetMethod].apply(targetObj, arguments);
-			};
-		};
-
-		var utc = {
-			date: d
-		};
-
-		// support strftime, if found
-
-		if (d.strftime != undefined) {
-			addProxyMethod(utc, "strftime", d, "strftime");
-		}
-
-		addProxyMethod(utc, "getTime", d, "getTime");
-		addProxyMethod(utc, "setTime", d, "setTime");
-
-		var props = ["Date", "Day", "FullYear", "Hours", "Milliseconds", "Minutes", "Month", "Seconds"];
-
-		for (var p = 0; p < props.length; p++) {
-			addProxyMethod(utc, "get" + props[p], d, "getUTC" + props[p]);
-			addProxyMethod(utc, "set" + props[p], d, "setUTC" + props[p]);
-		}
-
-		return utc;
-	};
-
-	// select time zone strategy.  This returns a date-like object tied to the
-	// desired timezone
-
-	function dateGenerator(ts, opts) {
-		if (opts.timezone == "browser") {
-			return new Date(ts);
-		} else if (!opts.timezone || opts.timezone == "utc") {
-			return makeUtcWrapper(new Date(ts));
-		} else if (typeof timezoneJS != "undefined" && typeof timezoneJS.Date != "undefined") {
-			var d = new timezoneJS.Date();
-			// timezone-js is fickle, so be sure to set the time zone before
-			// setting the time.
-			d.setTimezone(opts.timezone);
-			d.setTime(ts);
-			return d;
-		} else {
-			return makeUtcWrapper(new Date(ts));
-		}
-	}
-	
-	// map of app. size of time units in milliseconds
-
-	var timeUnitSize = {
-		"second": 1000,
-		"minute": 60 * 1000,
-		"hour": 60 * 60 * 1000,
-		"day": 24 * 60 * 60 * 1000,
-		"month": 30 * 24 * 60 * 60 * 1000,
-		"quarter": 3 * 30 * 24 * 60 * 60 * 1000,
-		"year": 365.2425 * 24 * 60 * 60 * 1000
-	};
-
-	// the allowed tick sizes, after 1 year we use
-	// an integer algorithm
-
-	var baseSpec = [
-		[1, "second"], [2, "second"], [5, "second"], [10, "second"],
-		[30, "second"], 
-		[1, "minute"], [2, "minute"], [5, "minute"], [10, "minute"],
-		[30, "minute"], 
-		[1, "hour"], [2, "hour"], [4, "hour"],
-		[8, "hour"], [12, "hour"],
-		[1, "day"], [2, "day"], [3, "day"],
-		[0.25, "month"], [0.5, "month"], [1, "month"],
-		[2, "month"]
-	];
-
-	// we don't know which variant(s) we'll need yet, but generating both is
-	// cheap
-
-	var specMonths = baseSpec.concat([[3, "month"], [6, "month"],
-		[1, "year"]]);
-	var specQuarters = baseSpec.concat([[1, "quarter"], [2, "quarter"],
-		[1, "year"]]);
-
-	function init(plot) {
-		plot.hooks.processOptions.push(function (plot, options) {
-			$.each(plot.getAxes(), function(axisName, axis) {
-
-				var opts = axis.options;
-
-				if (opts.mode == "time") {
-					axis.tickGenerator = function(axis) {
-
-						var ticks = [];
-						var d = dateGenerator(axis.min, opts);
-						var minSize = 0;
-
-						// make quarter use a possibility if quarters are
-						// mentioned in either of these options
-
-						var spec = (opts.tickSize && opts.tickSize[1] ===
-							"quarter") ||
-							(opts.minTickSize && opts.minTickSize[1] ===
-							"quarter") ? specQuarters : specMonths;
-
-						if (opts.minTickSize != null) {
-							if (typeof opts.tickSize == "number") {
-								minSize = opts.tickSize;
-							} else {
-								minSize = opts.minTickSize[0] * timeUnitSize[opts.minTickSize[1]];
-							}
-						}
-
-						for (var i = 0; i < spec.length - 1; ++i) {
-							if (axis.delta < (spec[i][0] * timeUnitSize[spec[i][1]]
-											  + spec[i + 1][0] * timeUnitSize[spec[i + 1][1]]) / 2
-								&& spec[i][0] * timeUnitSize[spec[i][1]] >= minSize) {
-								break;
-							}
-						}
-
-						var size = spec[i][0];
-						var unit = spec[i][1];
-
-						// special-case the possibility of several years
-
-						if (unit == "year") {
-
-							// if given a minTickSize in years, just use it,
-							// ensuring that it's an integer
-
-							if (opts.minTickSize != null && opts.minTickSize[1] == "year") {
-								size = Math.floor(opts.minTickSize[0]);
-							} else {
-
-								var magn = Math.pow(10, Math.floor(Math.log(axis.delta / timeUnitSize.year) / Math.LN10));
-								var norm = (axis.delta / timeUnitSize.year) / magn;
-
-								if (norm < 1.5) {
-									size = 1;
-								} else if (norm < 3) {
-									size = 2;
-								} else if (norm < 7.5) {
-									size = 5;
-								} else {
-									size = 10;
-								}
-
-								size *= magn;
-							}
-
-							// minimum size for years is 1
-
-							if (size < 1) {
-								size = 1;
-							}
-						}
-
-						axis.tickSize = opts.tickSize || [size, unit];
-						var tickSize = axis.tickSize[0];
-						unit = axis.tickSize[1];
-
-						var step = tickSize * timeUnitSize[unit];
-
-						if (unit == "second") {
-							d.setSeconds(floorInBase(d.getSeconds(), tickSize));
-						} else if (unit == "minute") {
-							d.setMinutes(floorInBase(d.getMinutes(), tickSize));
-						} else if (unit == "hour") {
-							d.setHours(floorInBase(d.getHours(), tickSize));
-						} else if (unit == "month") {
-							d.setMonth(floorInBase(d.getMonth(), tickSize));
-						} else if (unit == "quarter") {
-							d.setMonth(3 * floorInBase(d.getMonth() / 3,
-								tickSize));
-						} else if (unit == "year") {
-							d.setFullYear(floorInBase(d.getFullYear(), tickSize));
-						}
-
-						// reset smaller components
-
-						d.setMilliseconds(0);
-
-						if (step >= timeUnitSize.minute) {
-							d.setSeconds(0);
-						}
-						if (step >= timeUnitSize.hour) {
-							d.setMinutes(0);
-						}
-						if (step >= timeUnitSize.day) {
-							d.setHours(0);
-						}
-						if (step >= timeUnitSize.day * 4) {
-							d.setDate(1);
-						}
-						if (step >= timeUnitSize.month * 2) {
-							d.setMonth(floorInBase(d.getMonth(), 3));
-						}
-						if (step >= timeUnitSize.quarter * 2) {
-							d.setMonth(floorInBase(d.getMonth(), 6));
-						}
-						if (step >= timeUnitSize.year) {
-							d.setMonth(0);
-						}
-
-						var carry = 0;
-						var v = Number.NaN;
-						var prev;
-
-						do {
-
-							prev = v;
-							v = d.getTime();
-							ticks.push(v);
-
-							if (unit == "month" || unit == "quarter") {
-								if (tickSize < 1) {
-
-									// a bit complicated - we'll divide the
-									// month/quarter up but we need to take
-									// care of fractions so we don't end up in
-									// the middle of a day
-
-									d.setDate(1);
-									var start = d.getTime();
-									d.setMonth(d.getMonth() +
-										(unit == "quarter" ? 3 : 1));
-									var end = d.getTime();
-									d.setTime(v + carry * timeUnitSize.hour + (end - start) * tickSize);
-									carry = d.getHours();
-									d.setHours(0);
-								} else {
-									d.setMonth(d.getMonth() +
-										tickSize * (unit == "quarter" ? 3 : 1));
-								}
-							} else if (unit == "year") {
-								d.setFullYear(d.getFullYear() + tickSize);
-							} else {
-								d.setTime(v + step);
-							}
-						} while (v < axis.max && v != prev);
-
-						return ticks;
-					};
-
-					axis.tickFormatter = function (v, axis) {
-
-						var d = dateGenerator(v, axis.options);
-
-						// first check global format
-
-						if (opts.timeformat != null) {
-							return formatDate(d, opts.timeformat, opts.monthNames, opts.dayNames);
-						}
-
-						// possibly use quarters if quarters are mentioned in
-						// any of these places
-
-						var useQuarters = (axis.options.tickSize &&
-								axis.options.tickSize[1] == "quarter") ||
-							(axis.options.minTickSize &&
-								axis.options.minTickSize[1] == "quarter");
-
-						var t = axis.tickSize[0] * timeUnitSize[axis.tickSize[1]];
-						var span = axis.max - axis.min;
-						var suffix = (opts.twelveHourClock) ? " %p" : "";
-						var hourCode = (opts.twelveHourClock) ? "%I" : "%H";
-						var fmt;
-
-						if (t < timeUnitSize.minute) {
-							fmt = hourCode + ":%M:%S" + suffix;
-						} else if (t < timeUnitSize.day) {
-							if (span < 2 * timeUnitSize.day) {
-								fmt = hourCode + ":%M" + suffix;
-							} else {
-								fmt = "%b %d " + hourCode + ":%M" + suffix;
-							}
-						} else if (t < timeUnitSize.month) {
-							fmt = "%b %d";
-						} else if ((useQuarters && t < timeUnitSize.quarter) ||
-							(!useQuarters && t < timeUnitSize.year)) {
-							if (span < timeUnitSize.year) {
-								fmt = "%b";
-							} else {
-								fmt = "%b %Y";
-							}
-						} else if (useQuarters && t < timeUnitSize.year) {
-							if (span < timeUnitSize.year) {
-								fmt = "Q%q";
-							} else {
-								fmt = "Q%q %Y";
-							}
-						} else {
-							fmt = "%Y";
-						}
-
-						var rt = formatDate(d, fmt, opts.monthNames, opts.dayNames);
-
-						return rt;
-					};
-				}
-			});
-		});
-	}
-
-	$.plot.plugins.push({
-		init: init,
-		options: options,
-		name: 'time',
-		version: '1.0'
-	});
-
-	// Time-axis support used to be in Flot core, which exposed the
-	// formatDate function on the plot object.  Various plugins depend
-	// on the function, so we need to re-expose it here.
-
-	$.plot.formatDate = formatDate;
-	$.plot.dateGenerator = dateGenerator;
-
-})(jQuery);

rhodecode/public/js/jquery.flot.tooltip.js

@@ -1,488 +0,0 b''
-/*
- * jquery.flot.tooltip
- * 
- * description: easy-to-use tooltips for Flot charts
- * version: 0.8.4
- * authors: Krzysztof Urbas @krzysu [myviews.pl],Evan Steinkerchner @Roundaround
- * website: https://github.com/krzysu/flot.tooltip
- * 
- * build on 2014-08-06
- * released under MIT License, 2012
-*/ 
-(function ($) {
-    // plugin options, default values
-    var defaultOptions = {
-        tooltip: false,
-        tooltipOpts: {
-            id: "flotTip",
-            content: "%s | X: %x | Y: %y",
-            // allowed templates are:
-            // %s -> series label,
-            // %lx -> x axis label (requires flot-axislabels plugin https://github.com/markrcote/flot-axislabels),
-            // %ly -> y axis label (requires flot-axislabels plugin https://github.com/markrcote/flot-axislabels),
-            // %x -> X value,
-            // %y -> Y value,
-            // %x.2 -> precision of X value,
-            // %p -> percent
-            xDateFormat: null,
-            yDateFormat: null,
-            monthNames: null,
-            dayNames: null,
-            shifts: {
-                x: 10,
-                y: 20
-            },
-            defaultTheme: true,
-            lines: false,
-
-            // callbacks
-            onHover: function (flotItem, $tooltipEl) {},
-
-            $compat: false
-        }
-    };
-
-    // object
-    var FlotTooltip = function (plot) {
-        // variables
-        this.tipPosition = {x: 0, y: 0};
-
-        this.init(plot);
-    };
-
-    // main plugin function
-    FlotTooltip.prototype.init = function (plot) {
-        var that = this;
-
-        // detect other flot plugins
-        var plotPluginsLength = $.plot.plugins.length;
-        this.plotPlugins = [];
-
-        if (plotPluginsLength) {
-            for (var p = 0; p < plotPluginsLength; p++) {
-                this.plotPlugins.push($.plot.plugins[p].name);
-            }
-        }
-
-        plot.hooks.bindEvents.push(function (plot, eventHolder) {
-
-            // get plot options
-            that.plotOptions = plot.getOptions();
-
-            // if not enabled return
-            if (that.plotOptions.tooltip === false || typeof that.plotOptions.tooltip === 'undefined') return;
-
-            // shortcut to access tooltip options
-            that.tooltipOptions = that.plotOptions.tooltipOpts;
-
-            if (that.tooltipOptions.$compat) {
-                that.wfunc = 'width';
-                that.hfunc = 'height';
-            } else {
-                that.wfunc = 'innerWidth';
-                that.hfunc = 'innerHeight';
-            }
-
-            // create tooltip DOM element
-            var $tip = that.getDomElement();
-
-            // bind event
-            $( plot.getPlaceholder() ).bind("plothover", plothover);
-
-            $(eventHolder).bind('mousemove', mouseMove);
-        });
-
-        plot.hooks.shutdown.push(function (plot, eventHolder){
-            $(plot.getPlaceholder()).unbind("plothover", plothover);
-            $(eventHolder).unbind("mousemove", mouseMove);
-        });
-
-        function mouseMove(e){
-            var pos = {};
-            pos.x = e.pageX;
-            pos.y = e.pageY;
-            plot.setTooltipPosition(pos);
-        }
-
-        function plothover(event, pos, item) {
-            // Simple distance formula.
-            var lineDistance = function (p1x, p1y, p2x, p2y) {
-                return Math.sqrt((p2x - p1x) * (p2x - p1x) + (p2y - p1y) * (p2y - p1y));
-            };
-
-            // Here is some voodoo magic for determining the distance to a line form a given point {x, y}.
-            var dotLineLength = function (x, y, x0, y0, x1, y1, o) {
-                if (o && !(o =
-                    function (x, y, x0, y0, x1, y1) {
-                        if (typeof x0 !== 'undefined') return { x: x0, y: y };
-                        else if (typeof y0 !== 'undefined') return { x: x, y: y0 };
-
-                        var left,
-                            tg = -1 / ((y1 - y0) / (x1 - x0));
-
-                        return {
-                            x: left = (x1 * (x * tg - y + y0) + x0 * (x * -tg + y - y1)) / (tg * (x1 - x0) + y0 - y1),
-                            y: tg * left - tg * x + y
-                        };
-                    } (x, y, x0, y0, x1, y1),
-                    o.x >= Math.min(x0, x1) && o.x <= Math.max(x0, x1) && o.y >= Math.min(y0, y1) && o.y <= Math.max(y0, y1))
-                ) {
-                    var l1 = lineDistance(x, y, x0, y0), l2 = lineDistance(x, y, x1, y1);
-                    return l1 > l2 ? l2 : l1;
-                } else {
-                    var a = y0 - y1, b = x1 - x0, c = x0 * y1 - y0 * x1;
-                    return Math.abs(a * x + b * y + c) / Math.sqrt(a * a + b * b);
-                }
-            };
-
-            if (item) {
-                plot.showTooltip(item, pos);
-            } else if (that.plotOptions.series.lines.show && that.tooltipOptions.lines === true) {
-                var maxDistance = that.plotOptions.grid.mouseActiveRadius;
-
-                var closestTrace = {
-                    distance: maxDistance + 1
-                };
-
-                $.each(plot.getData(), function (i, series) {
-                    var xBeforeIndex = 0,
-                        xAfterIndex = -1;
-
-                    // Our search here assumes our data is sorted via the x-axis.
-                    // TODO: Improve efficiency somehow - search smaller sets of data.
-                    for (var j = 1; j < series.data.length; j++) {
-                        if (series.data[j - 1][0] <= pos.x && series.data[j][0] >= pos.x) {
-                            xBeforeIndex = j - 1;
-                            xAfterIndex = j;
-                        }
-                    }
-
-                    if (xAfterIndex === -1) {
-                        plot.hideTooltip();
-                        return;
-                    }
-
-                    var pointPrev = { x: series.data[xBeforeIndex][0], y: series.data[xBeforeIndex][1] },
-                        pointNext = { x: series.data[xAfterIndex][0], y: series.data[xAfterIndex][1] };
-
-                    var distToLine = dotLineLength(series.xaxis.p2c(pos.x), series.yaxis.p2c(pos.y), series.xaxis.p2c(pointPrev.x),
-                        series.yaxis.p2c(pointPrev.y), series.xaxis.p2c(pointNext.x), series.yaxis.p2c(pointNext.y), false);
-
-                    if (distToLine < closestTrace.distance) {
-
-                        var closestIndex = lineDistance(pointPrev.x, pointPrev.y, pos.x, pos.y) <
-                            lineDistance(pos.x, pos.y, pointNext.x, pointNext.y) ? xBeforeIndex : xAfterIndex;
-
-                        var pointSize = series.datapoints.pointsize;
-
-                        // Calculate the point on the line vertically closest to our cursor.
-                        var pointOnLine = [
-                            pos.x,
-                            pointPrev.y + ((pointNext.y - pointPrev.y) * ((pos.x - pointPrev.x) / (pointNext.x - pointPrev.x)))
-                        ];
-
-                        var item = {
-                            datapoint: pointOnLine,
-                            dataIndex: closestIndex,
-                            series: series,
-                            seriesIndex: i
-                        };
-
-                        closestTrace = {
-                            distance: distToLine,
-                            item: item
-                        };
-                    }
-                });
-
-                if (closestTrace.distance < maxDistance + 1)
-                    plot.showTooltip(closestTrace.item, pos);
-                else
-                    plot.hideTooltip();
-            } else {
-                plot.hideTooltip();
-            }
-        }
-
-	    // Quick little function for setting the tooltip position.
-	    plot.setTooltipPosition = function (pos) {
-	        var $tip = that.getDomElement();
-
-	        var totalTipWidth = $tip.outerWidth() + that.tooltipOptions.shifts.x;
-	        var totalTipHeight = $tip.outerHeight() + that.tooltipOptions.shifts.y;
-	        if ((pos.x - $(window).scrollLeft()) > ($(window)[that.wfunc]() - totalTipWidth)) {
-	            pos.x -= totalTipWidth;
-	        }
-	        if ((pos.y - $(window).scrollTop()) > ($(window)[that.hfunc]() - totalTipHeight)) {
-	            pos.y -= totalTipHeight;
-	        }
-	        that.tipPosition.x = pos.x;
-	        that.tipPosition.y = pos.y;
-	    };
-
-	    // Quick little function for showing the tooltip.
-	    plot.showTooltip = function (target, position) {
-	        var $tip = that.getDomElement();
-
-	        // convert tooltip content template to real tipText
-	        var tipText = that.stringFormat(that.tooltipOptions.content, target);
-
-	        $tip.html(tipText);
-	        plot.setTooltipPosition({ x: position.pageX, y: position.pageY });
-	        $tip.css({
-	            left: that.tipPosition.x + that.tooltipOptions.shifts.x,
-	            top: that.tipPosition.y + that.tooltipOptions.shifts.y
-	        }).show();
-
-	        // run callback
-	        if (typeof that.tooltipOptions.onHover === 'function') {
-	            that.tooltipOptions.onHover(target, $tip);
-	        }
-	    };
-
-	    // Quick little function for hiding the tooltip.
-	    plot.hideTooltip = function () {
-	        that.getDomElement().hide().html('');
-	    };
-    };
-
-    /**
-     * get or create tooltip DOM element
-     * @return jQuery object
-     */
-    FlotTooltip.prototype.getDomElement = function () {
-        var $tip = $('#' + this.tooltipOptions.id);
-
-        if( $tip.length === 0 ){
-            $tip = $('<div />').attr('id', this.tooltipOptions.id);
-            $tip.appendTo('body').hide().css({position: 'absolute'});
-
-            if(this.tooltipOptions.defaultTheme) {
-                $tip.css({
-                    'background': '#fff',
-                    'z-index': '1040',
-                    'padding': '0.4em 0.6em',
-                    'border-radius': '0.5em',
-                    'font-size': '0.8em',
-                    'border': '1px solid #111',
-                    'display': 'none',
-                    'white-space': 'nowrap'
-                });
-            }
-        }
-
-        return $tip;
-    };
-
-    /**
-     * core function, create tooltip content
-     * @param  {string} content - template with tooltip content
-     * @param  {object} item - Flot item
-     * @return {string} real tooltip content for current item
-     */
-    FlotTooltip.prototype.stringFormat = function (content, item) {
-
-        var percentPattern = /%p\.{0,1}(\d{0,})/;
-        var seriesPattern = /%s/;
-        var xLabelPattern = /%lx/; // requires flot-axislabels plugin https://github.com/markrcote/flot-axislabels, will be ignored if plugin isn't loaded
-        var yLabelPattern = /%ly/; // requires flot-axislabels plugin https://github.com/markrcote/flot-axislabels, will be ignored if plugin isn't loaded
-        var xPattern = /%x\.{0,1}(\d{0,})/;
-        var yPattern = /%y\.{0,1}(\d{0,})/;
-        var xPatternWithoutPrecision = "%x";
-        var yPatternWithoutPrecision = "%y";
-        var customTextPattern = "%ct";
-
-        var x, y, customText, p;
-
-        // for threshold plugin we need to read data from different place
-        if (typeof item.series.threshold !== "undefined") {
-            x = item.datapoint[0];
-            y = item.datapoint[1];
-            customText = item.datapoint[2];
-        } else if (typeof item.series.lines !== "undefined" && item.series.lines.steps) {
-            x = item.series.datapoints.points[item.dataIndex * 2];
-            y = item.series.datapoints.points[item.dataIndex * 2 + 1];
-            // TODO: where to find custom text in this variant?
-            customText = "";
-        } else {
-            x = item.series.data[item.dataIndex][0];
-            y = item.series.data[item.dataIndex][1];
-            customText = item.series.data[item.dataIndex][2];
-        }
-
-        // I think this is only in case of threshold plugin
-        if (item.series.label === null && item.series.originSeries) {
-            item.series.label = item.series.originSeries.label;
-        }
-
-        // if it is a function callback get the content string
-        if (typeof(content) === 'function') {
-            content = content(item.series.label, x, y, item);
-        }
-
-        // percent match for pie charts and stacked percent
-        if (typeof (item.series.percent) !== 'undefined') {
-            p = item.series.percent;
-        } else if (typeof (item.series.percents) !== 'undefined') {
-            p = item.series.percents[item.dataIndex];
-        }        
-        if (typeof p === 'number') {
-            content = this.adjustValPrecision(percentPattern, content, p);
-        }
-
-        // series match
-        if (typeof(item.series.label) !== 'undefined') {
-            content = content.replace(seriesPattern, item.series.label);
-        } else {
-            //remove %s if label is undefined
-            content = content.replace(seriesPattern, "");
-        }
-
-        // x axis label match
-        if (this.hasAxisLabel('xaxis', item)) {
-            content = content.replace(xLabelPattern, item.series.xaxis.options.axisLabel);
-        } else {
-            //remove %lx if axis label is undefined or axislabels plugin not present
-            content = content.replace(xLabelPattern, "");
-        }
-
-        // y axis label match
-        if (this.hasAxisLabel('yaxis', item)) {
-            content = content.replace(yLabelPattern, item.series.yaxis.options.axisLabel);
-        } else {
-            //remove %ly if axis label is undefined or axislabels plugin not present
-            content = content.replace(yLabelPattern, "");
-        }
-
-        // time mode axes with custom dateFormat
-        if (this.isTimeMode('xaxis', item) && this.isXDateFormat(item)) {
-            content = content.replace(xPattern, this.timestampToDate(x, this.tooltipOptions.xDateFormat, item.series.xaxis.options));
-        }
-		if (this.isTimeMode('yaxis', item) && this.isYDateFormat(item)) {
-            content = content.replace(yPattern, this.timestampToDate(y, this.tooltipOptions.yDateFormat, item.series.yaxis.options));
-        }
-
-        // set precision if defined
-        if (typeof x === 'number') {
-            content = this.adjustValPrecision(xPattern, content, x);
-        }
-        if (typeof y === 'number') {
-            content = this.adjustValPrecision(yPattern, content, y);
-        }
-
-        // change x from number to given label, if given
-        if (typeof item.series.xaxis.ticks !== 'undefined') {
-
-            var ticks;
-            if (this.hasRotatedXAxisTicks(item)) {
-                // xaxis.ticks will be an empty array if tickRotor is being used, but the values are available in rotatedTicks
-                ticks = 'rotatedTicks';
-            } else {
-                ticks = 'ticks';
-            }
-
-            // see https://github.com/krzysu/flot.tooltip/issues/65
-            var tickIndex = item.dataIndex + item.seriesIndex;
-
-            if (item.series.xaxis[ticks].length > tickIndex && !this.isTimeMode('xaxis', item)) {
-                var valueX = (this.isCategoriesMode('xaxis', item)) ? item.series.xaxis[ticks][tickIndex].label : item.series.xaxis[ticks][tickIndex].v;
-                if (valueX === x) {
-                    content = content.replace(xPattern, item.series.xaxis[ticks][tickIndex].label);
-                }
-            }
-        }
-
-        // change y from number to given label, if given
-        if (typeof item.series.yaxis.ticks !== 'undefined') {
-            for (var index in item.series.yaxis.ticks) {
-                if (item.series.yaxis.ticks.hasOwnProperty(index)) {
-                    var valueY = (this.isCategoriesMode('yaxis', item)) ? item.series.yaxis.ticks[index].label : item.series.yaxis.ticks[index].v;
-                    if (valueY === y) {
-                        content = content.replace(yPattern, item.series.yaxis.ticks[index].label);
-                    }
-                }
-            }
-        }
-
-        // if no value customization, use tickFormatter by default
-        if (typeof item.series.xaxis.tickFormatter !== 'undefined') {
-            //escape dollar
-            content = content.replace(xPatternWithoutPrecision, item.series.xaxis.tickFormatter(x, item.series.xaxis).replace(/\$/g, '$$'));
-        }
-        if (typeof item.series.yaxis.tickFormatter !== 'undefined') {
-            //escape dollar
-            content = content.replace(yPatternWithoutPrecision, item.series.yaxis.tickFormatter(y, item.series.yaxis).replace(/\$/g, '$$'));
-        }
-
-        if (customText)
-            content = content.replace(customTextPattern, customText);
-
-        return content;
-    };
-
-    // helpers just for readability
-    FlotTooltip.prototype.isTimeMode = function (axisName, item) {
-        return (typeof item.series[axisName].options.mode !== 'undefined' && item.series[axisName].options.mode === 'time');
-    };
-
-    FlotTooltip.prototype.isXDateFormat = function (item) {
-        return (typeof this.tooltipOptions.xDateFormat !== 'undefined' && this.tooltipOptions.xDateFormat !== null);
-    };
-
-    FlotTooltip.prototype.isYDateFormat = function (item) {
-        return (typeof this.tooltipOptions.yDateFormat !== 'undefined' && this.tooltipOptions.yDateFormat !== null);
-    };
-
-    FlotTooltip.prototype.isCategoriesMode = function (axisName, item) {
-        return (typeof item.series[axisName].options.mode !== 'undefined' && item.series[axisName].options.mode === 'categories');
-    };
-
-    //
-    FlotTooltip.prototype.timestampToDate = function (tmst, dateFormat, options) {
-        var theDate = $.plot.dateGenerator(tmst, options);
-        return $.plot.formatDate(theDate, dateFormat, this.tooltipOptions.monthNames, this.tooltipOptions.dayNames);
-    };
-
-    //
-    FlotTooltip.prototype.adjustValPrecision = function (pattern, content, value) {
-
-        var precision;
-        var matchResult = content.match(pattern);
-        if( matchResult !== null ) {
-            if(RegExp.$1 !== '') {
-                precision = RegExp.$1;
-                value = value.toFixed(precision);
-
-                // only replace content if precision exists, in other case use thickformater
-                content = content.replace(pattern, value);
-            }
-        }
-        return content;
-    };
-
-    // other plugins detection below
-
-    // check if flot-axislabels plugin (https://github.com/markrcote/flot-axislabels) is used and that an axis label is given
-    FlotTooltip.prototype.hasAxisLabel = function (axisName, item) {
-        return ($.inArray(this.plotPlugins, 'axisLabels') !== -1 && typeof item.series[axisName].options.axisLabel !== 'undefined' && item.series[axisName].options.axisLabel.length > 0);
-    };
-
-    // check whether flot-tickRotor, a plugin which allows rotation of X-axis ticks, is being used
-    FlotTooltip.prototype.hasRotatedXAxisTicks = function (item) {
-        return ($.inArray(this.plotPlugins, 'tickRotor') !== -1 && typeof item.series.xaxis.rotatedTicks !== 'undefined');
-    };
-
-    //
-    var init = function (plot) {
-      new FlotTooltip(plot);
-    };
-
-    // define Flot plugin
-    $.plot.plugins.push({
-        init: init,
-        options: defaultOptions,
-        name: 'tooltip',
-        version: '0.8.4'
-    });
-
-})(jQuery);

rhodecode/public/js/src/appenlight-client-0.4.1.min.js

@@ -1,2 +0,0 b''
-/*! appenlight-client 29-01-2016 */
-!function(a){"use strict";var b={version:"0.4.1",options:{apiKey:""},errorReportBuffer:[],slowReportBuffer:[],logBuffer:[],requestInfo:null,init:function(b){var c=this;"undefined"==typeof b.server&&(b.server="https://api.appenlight.com"),"undefined"==typeof b.apiKey&&(b.apiKey="undefined"),"undefined"==typeof b.protocol_version&&(b.protocol_version="0.5"),("undefined"==typeof b.windowOnError||0==b.windowOnError)&&(TraceKit.collectWindowErrors=!1),"undefined"==typeof b.sendInterval&&(b.sendInterval=1e3),"undefined"==typeof b.tracekitRemoteFetching&&(b.tracekitRemoteFetching=!0),"undefined"==typeof b.tracekitContextLines&&(b.tracekitContextLines=11),b.sendInterval>=1e3&&this.createSendInterval(b.sendInterval),this.options=b,this.requestInfo={url:a.location.href},this.reportsEndpoint=b.server+"/api/reports?public_api_key="+this.options.apiKey+"&protocol_version="+this.options.protocol_version,this.logsEndpoint=b.server+"/api/logs?public_api_key="+this.options.apiKey+"&protocol_version="+this.options.protocol_version,TraceKit.remoteFetching=b.tracekitRemoteFetching,TraceKit.linesOfContext=b.tracekitContextLines,TraceKit.report.subscribe(function(a){c.handleError(a)})},createSendInterval:function(a){var b=this;this.send_iv=setInterval(function(){b.sendReports(),b.sendLogs()},a)},setRequestInfo:function(a){for(var b in a)this.requestInfo[b]=a[b]},grabError:function(a){try{TraceKit.report(a)}catch(b){if(a!==b)throw b}},handleError:function(b){if("stack"==b.mode)var c=b.name+": "+b.message;else var c=b.message;var d={client:"javascript",language:"javascript",error:c,occurences:1,priority:5,server:"",http_status:500,request:{},traceback:[]};if(d.user_agent=a.navigator.userAgent,d.start_time=(new Date).toJSON(),null!=this.requestInfo)for(var e in this.requestInfo)d[e]=this.requestInfo[e];"undefined"!=typeof d.request_id&&d.request_id||(d.request_id=this.genUUID4());for(var f=b.stack.reverse().slice(-100),e=0;e<f.length;e++){var g="";try{if(f[e].context)for(var h=0;h<f[e].context.length;h++){var i=f[e].context[h];g+=i.length>300?"<minified-context>":i,g+="\n"}}catch(j){}var k={cline:g,file:f[e].url,fn:f[e].func,line:f[e].line,vars:[]};d.traceback.push(k)}d.traceback.length>0&&(d.traceback[d.traceback.length-1].cline=g+"\n"+c),this.errorReportBuffer.push(d)},log:function(b,c,d,e){if("undefined"==typeof d)var d=a.location.pathname;if("undefined"==typeof e)var e=null;this.logBuffer.push({log_level:b.toUpperCase(),message:c,date:(new Date).toJSON(),namespace:d}),null!=this.requestInfo&&"undefined"!=typeof this.requestInfo.server&&(this.logBuffer[this.logBuffer.length-1].server=this.requestInfo.server)},genUUID4:function(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,function(a){var b=16*Math.random()|0,c="x"==a?b:3&b|8;return c.toString(16)})},sendReports:function(){if(this.errorReportBuffer.length<1)return!0;var a=this.errorReportBuffer;return this.submitData(this.reportsEndpoint,a),this.errorReportBuffer=[],!0},sendLogs:function(){if(this.logBuffer.length<1)return!0;var a=this.logBuffer;return this.submitData(this.logsEndpoint,a),this.logBuffer=[],!0},submitData:function(b,c){var d=new a.XMLHttpRequest;!d&&a.ActiveXObject&&(d=new a.ActiveXObject("Microsoft.XMLHTTP")),d.open("POST",b,!0),d.setRequestHeader("Content-Type","application/json"),d.send(JSON.stringify(c))}};a.AppEnlight=b,"function"==typeof define&&define.amd&&define("appenlight",[],function(){return b})}(window),function(a,b){function c(a,b){return Object.prototype.hasOwnProperty.call(a,b)}function d(a){return"undefined"==typeof a}if(a){var e={},f=a.TraceKit,g=[].slice,h="?";e.noConflict=function(){return a.TraceKit=f,e},e.wrap=function(a){function b(){try{return a.apply(this,arguments)}catch(b){throw e.report(b),b}}return b},e.report=function(){function b(a){i(),n.push(a)}function d(a){for(var b=n.length-1;b>=0;--b)n[b]===a&&n.splice(b,1)}function f(a,b){var d=null;if(!b||e.collectWindowErrors){for(var f in n)if(c(n,f))try{n[f].apply(null,[a].concat(g.call(arguments,2)))}catch(h){d=h}if(d)throw d}}function h(a,b,c,d,g){var h=null;if(q)e.computeStackTrace.augmentStackTraceWithInitialElement(q,b,c,a),j();else if(g)h=e.computeStackTrace(g),f(h,!0);else{var i={url:b,line:c,column:d};i.func=e.computeStackTrace.guessFunctionName(i.url,i.line),i.context=e.computeStackTrace.gatherContext(i.url,i.line),h={mode:"onerror",message:a,stack:[i]},f(h,!0)}return l?l.apply(this,arguments):!1}function i(){m!==!0&&(l=a.onerror,a.onerror=h,m=!0)}function j(){var a=q,b=o;o=null,q=null,p=null,f.apply(null,[a,!1].concat(b))}function k(b){if(q){if(p===b)return;j()}var c=e.computeStackTrace(b);throw q=c,p=b,o=g.call(arguments,1),a.setTimeout(function(){p===b&&j()},c.incomplete?2e3:0),b}var l,m,n=[],o=null,p=null,q=null;return k.subscribe=b,k.unsubscribe=d,k}(),e.computeStackTrace=function(){function b(b){if(!e.remoteFetching)return"";try{var c=function(){try{return new a.XMLHttpRequest}catch(b){return new a.ActiveXObject("Microsoft.XMLHTTP")}},d=c();return d.open("GET",b,!1),d.send(""),d.responseText}catch(f){return""}}function f(a){if("string"!=typeof a)return[];if(!c(w,a)){var d="",e="";try{e=document.domain}catch(f){}-1!==a.indexOf(e)&&(d=b(a)),w[a]=d?d.split("\n"):[]}return w[a]}function g(a,b){var c,e=/function ([^(]*)\(([^)]*)\)/,g=/['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,i="",j=10,k=f(a);if(!k.length)return h;for(var l=0;j>l;++l)if(i=k[b-l]+i,!d(i)){if(c=g.exec(i))return c[1];if(c=e.exec(i))return c[1]}return h}function i(a,b){var c=f(a);if(!c.length)return null;var g=[],h=Math.floor(e.linesOfContext/2),i=h+e.linesOfContext%2,j=Math.max(0,b-h-1),k=Math.min(c.length,b+i-1);b-=1;for(var l=j;k>l;++l)d(c[l])||g.push(c[l]);return g.length>0?g:null}function j(a){return a.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g,"\\$&")}function k(a){return j(a).replace("<","(?:<|&lt;)").replace(">","(?:>|&gt;)").replace("&","(?:&|&amp;)").replace('"','(?:"|&quot;)').replace(/\s+/g,"\\s+")}function l(a,b){for(var c,d,e=0,g=b.length;g>e;++e)if((c=f(b[e])).length&&(c=c.join("\n"),d=a.exec(c)))return{url:b[e],line:c.substring(0,d.index).split("\n").length,column:d.index-c.lastIndexOf("\n",d.index)-1};return null}function m(a,b,c){var d,e=f(b),g=new RegExp("\\b"+j(a)+"\\b");return c-=1,e&&e.length>c&&(d=g.exec(e[c]))?d.index:null}function n(b){if(!d(document)){for(var c,e,f,g,h=[a.location.href],i=document.getElementsByTagName("script"),m=""+b,n=/^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,o=/^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,p=0;p<i.length;++p){var q=i[p];q.src&&h.push(q.src)}if(f=n.exec(m)){var r=f[1]?"\\s+"+f[1]:"",s=f[2].split(",").join("\\s*,\\s*");c=j(f[3]).replace(/;$/,";?"),e=new RegExp("function"+r+"\\s*\\(\\s*"+s+"\\s*\\)\\s*{\\s*"+c+"\\s*}")}else e=new RegExp(j(m).replace(/\s+/g,"\\s+"));if(g=l(e,h))return g;if(f=o.exec(m)){var t=f[1];if(c=k(f[2]),e=new RegExp("on"+t+"=[\\'\"]\\s*"+c+"\\s*[\\'\"]","i"),g=l(e,h[0]))return g;if(e=new RegExp(c),g=l(e,h))return g}return null}}function o(a){if(!a.stack)return null;for(var b,c,e=/^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,f=/^\s*(.*?)(?:\((.*?)\))?@?((?:file|https?|blob|chrome|\[).*?)(?::(\d+))?(?::(\d+))?\s*$/i,j=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:ms-appx|https?|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,k=a.stack.split("\n"),l=[],n=/^(.*) is undefined$/.exec(a.message),o=0,p=k.length;p>o;++o){if(b=e.exec(k[o])){var q=b[2]&&-1!==b[2].indexOf("native");c={url:q?null:b[2],func:b[1]||h,args:q?[b[2]]:[],line:b[3]?+b[3]:null,column:b[4]?+b[4]:null}}else if(b=j.exec(k[o]))c={url:b[2],func:b[1]||h,args:[],line:+b[3],column:b[4]?+b[4]:null};else{if(!(b=f.exec(k[o])))continue;c={url:b[3],func:b[1]||h,args:b[2]?b[2].split(","):[],line:b[4]?+b[4]:null,column:b[5]?+b[5]:null}}!c.func&&c.line&&(c.func=g(c.url,c.line)),c.line&&(c.context=i(c.url,c.line)),l.push(c)}return l.length?(l[0]&&l[0].line&&!l[0].column&&n?l[0].column=m(n[1],l[0].url,l[0].line):l[0].column||d(a.columnNumber)||(l[0].column=a.columnNumber+1),{mode:"stack",name:a.name,message:a.message,stack:l}):null}function p(a){var b=a.stacktrace;if(b){for(var c,d=/ line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,e=/ line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\))? in (.*):\s*$/i,f=b.split("\n"),h=[],j=0;j<f.length;j+=2){var k=null;if((c=d.exec(f[j]))?k={url:c[2],line:+c[1],column:null,func:c[3],args:[]}:(c=e.exec(f[j]))&&(k={url:c[6],line:+c[1],column:+c[2],func:c[3]||c[4],args:c[5]?c[5].split(","):[]}),k){if(!k.func&&k.line&&(k.func=g(k.url,k.line)),k.line)try{k.context=i(k.url,k.line)}catch(l){}k.context||(k.context=[f[j+1]]),h.push(k)}}return h.length?{mode:"stacktrace",name:a.name,message:a.message,stack:h}:null}}function q(b){var d=b.message.split("\n");if(d.length<4)return null;var e,h=/^\s*Line (\d+) of linked script ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,j=/^\s*Line (\d+) of inline#(\d+) script in ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,m=/^\s*Line (\d+) of function script\s*$/i,n=[],o=document.getElementsByTagName("script"),p=[];for(var q in o)c(o,q)&&!o[q].src&&p.push(o[q]);for(var r=2;r<d.length;r+=2){var s=null;if(e=h.exec(d[r]))s={url:e[2],func:e[3],args:[],line:+e[1],column:null};else if(e=j.exec(d[r])){s={url:e[3],func:e[4],args:[],line:+e[1],column:null};var t=+e[1],u=p[e[2]-1];if(u){var v=f(s.url);if(v){v=v.join("\n");var w=v.indexOf(u.innerText);w>=0&&(s.line=t+v.substring(0,w).split("\n").length)}}}else if(e=m.exec(d[r])){var x=a.location.href.replace(/#.*$/,""),y=new RegExp(k(d[r+1])),z=l(y,[x]);s={url:x,func:"",args:[],line:z?z.line:e[1],column:null}}if(s){s.func||(s.func=g(s.url,s.line));var A=i(s.url,s.line),B=A?A[Math.floor(A.length/2)]:null;A&&B.replace(/^\s*/,"")===d[r+1].replace(/^\s*/,"")?s.context=A:s.context=[d[r+1]],n.push(s)}}return n.length?{mode:"multiline",name:b.name,message:d[0],stack:n}:null}function r(a,b,c,d){var e={url:b,line:c};if(e.url&&e.line){a.incomplete=!1,e.func||(e.func=g(e.url,e.line)),e.context||(e.context=i(e.url,e.line));var f=/ '([^']+)' /.exec(d);if(f&&(e.column=m(f[1],e.url,e.line)),a.stack.length>0&&a.stack[0].url===e.url){if(a.stack[0].line===e.line)return!1;if(!a.stack[0].line&&a.stack[0].func===e.func)return a.stack[0].line=e.line,a.stack[0].context=e.context,!1}return a.stack.unshift(e),a.partial=!0,!0}return a.incomplete=!0,!1}function s(a,b){for(var c,d,f,i=/function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i,j=[],k={},l=!1,o=s.caller;o&&!l;o=o.caller)if(o!==t&&o!==e.report){if(d={url:null,func:h,args:[],line:null,column:null},o.name?d.func=o.name:(c=i.exec(o.toString()))&&(d.func=c[1]),"undefined"==typeof d.func)try{d.func=c.input.substring(0,c.input.indexOf("{"))}catch(p){}if(f=n(o)){d.url=f.url,d.line=f.line,d.func===h&&(d.func=g(d.url,d.line));var q=/ '([^']+)' /.exec(a.message||a.description);q&&(d.column=m(q[1],f.url,f.line))}k[""+o]?l=!0:k[""+o]=!0,j.push(d)}b&&j.splice(0,b);var u={mode:"callers",name:a.name,message:a.message,stack:j};return r(u,a.sourceURL||a.fileName,a.line||a.lineNumber,a.message||a.description),u}function t(a,b){var c=null;b=null==b?0:+b;try{if(c=p(a))return c}catch(d){if(v)throw d}try{if(c=o(a))return c}catch(d){if(v)throw d}try{if(c=q(a))return c}catch(d){if(v)throw d}try{if(c=s(a,b+1))return c}catch(d){if(v)throw d}return{mode:"failed"}}function u(a){a=(null==a?0:+a)+1;try{throw new Error}catch(b){return t(b,a+1)}}var v=!1,w={};return t.augmentStackTraceWithInitialElement=r,t.guessFunctionName=g,t.gatherContext=i,t.ofCaller=u,t.getSource=f,t}(),e.extendToAsynchronousCallbacks=function(){var b=function(b){var c=a[b];a[b]=function(){var a=g.call(arguments),b=a[0];return"function"==typeof b&&(a[0]=e.wrap(b)),c.apply?c.apply(this,a):c(a[0],a[1])}};b("setTimeout"),b("setInterval")},e.remoteFetching||(e.remoteFetching=!0),e.collectWindowErrors||(e.collectWindowErrors=!0),(!e.linesOfContext||e.linesOfContext<1)&&(e.linesOfContext=11),a.TraceKit=e}}("undefined"!=typeof window?window:global);
  No newline at end of file

rhodecode/public/js/src/rhodecode/widgets/multiselect.js

@@ -1,132 +0,0 b''
-// # Copyright (C) 2010-2016  RhodeCode GmbH
-// #
-// # This program is free software: you can redistribute it and/or modify
-// # it under the terms of the GNU Affero General Public License, version 3
-// # (only), as published by the Free Software Foundation.
-// #
-// # This program is distributed in the hope that it will be useful,
-// # but WITHOUT ANY WARRANTY; without even the implied warranty of
-// # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// # GNU General Public License for more details.
-// #
-// # You should have received a copy of the GNU Affero General Public License
-// # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-// #
-// # This program is dual-licensed. If you wish to learn more about the
-// # RhodeCode Enterprise Edition, including its added features, Support services,
-// # and proprietary license terms, please see https://rhodecode.com/licenses/
-
-/**
- * Multi select widget
- */
-var MultiSelectWidget = function(selected_id, available_id, form_id){
-  // definition of containers ID's
-  var selected_container = selected_id;
-  var available_container = available_id;
-  // temp container for selected storage.
-  var cache = [];
-  var av_cache = [];
-  var c = $('#'+selected_container).get(0);
-  var ac = $('#'+available_container).get(0);
-  // get only selected options for further fullfilment
-  for (var i = 0; node = c.options[i]; i++){
-    if (node.selected){
-      // push selected to my temp storage left overs :)
-      cache.push(node);
-    }
-  }
-  // get all available options to cache
-  for (i = 0; node = ac.options[i]; i++){
-    // push selected to my temp storage left overs :)
-    av_cache.push(node);
-  }
-  // fill available only with those not in chosen
-  ac.options.length = 0;
-  tmp_cache = [];
-
-  for (i = 0; node = av_cache[i]; i++){
-    var add = true;
-    for (var i2 = 0; node_2 = cache[i2]; i2++){
-      if (node.value === node_2.value){
-        add=false;
-        break;
-      }
-    }
-    if(add){
-      tmp_cache.push(new Option(node.text, node.value, false, false));
-    }
-  }
-  for (i = 0; node = tmp_cache[i]; i++){
-    ac.options[i] = node;
-  }
-  function prompts_action_callback(e){
-    var chosen  = $('#'+selected_container).get(0);
-    var available = $('#'+available_container).get(0);
-    // get checked and unchecked options from field
-    function get_checked(from_field){
-      // temp container for storage.
-      var sel_cache = [];
-      var oth_cache = [];
-
-      for (i = 0; node = from_field.options[i]; i++){
-        if(node.selected){
-          // push selected fields :)
-          sel_cache.push(node);
-        }
-        else {
-          oth_cache.push(node);
-        }
-      }
-      return [sel_cache,oth_cache];
-    }
-    // fill the field with given options
-    function fill_with(field,options){
-      // clear firtst
-      field.options.length=0;
-      for (var i = 0; node = options[i]; i++){
-        field.options[i] = new Option(node.text, node.value, false, false);
-      }
-    }
-    // adds to current field
-    function add_to(field,options){
-      for (i = 0; node = options[i]; i++){
-        field.appendChild(new Option(node.text, node.value, false, false));
-      }
-    }
-    // add action
-    if (this.id ==='add_element'){
-      var c = get_checked(available);
-      add_to(chosen,c[0]);
-      fill_with(available,c[1]);
-    }
-    // remove action
-    if (this.id ==='remove_element'){
-      c = get_checked(chosen);
-      add_to(available,c[0]);
-      fill_with(chosen,c[1]);
-    }
-    // add all elements
-    if(this.id === 'add_all_elements'){
-      for (i=0; node = available.options[i]; i++){
-        chosen.appendChild(new Option(node.text, node.value, false, false));
-      }
-      available.options.length = 0;
-    }
-    // remove all elements
-    if (this.id === 'remove_all_elements'){
-      for (i=0; node = chosen.options[i]; i++){
-        available.appendChild(new Option(node.text, node.value, false, false));
-      }
-      chosen.options.length = 0;
-    }
-  }
-  $('#add_element, #remove_element, #add_all_elements, #remove_all_elements').click(prompts_action_callback);
-  if (form_id !== undefined) {
-    $('#'+form_id).submit(function(){
-      var chosen  = $('#'+selected_container).get(0);
-      for (i = 0; i < chosen.options.length; i++) {
-        chosen.options[i].selected = 'selected';
-      }
-    });
-  }
-};

rhodecode/templates/admin/user_groups/user_group_edit_members.html

@@ -1,30 +0,0 b''
-<%namespace name="base" file="/base/base.html"/>
-
-<div class="panel panel-default">
-  <div class="panel-heading">
-      <h3 class="panel-title">${_('Members of User Group: %s') % c.user_group.users_group_name}</h3>
-  </div>
-  <div class="panel-body">
-    % if c.group_members_obj:
-      <table class="rctable group_members">
-        <tr>
-          <th>Username</th>
-          <th>Name</th>
-        </tr>
-      %for user in c.group_members_obj:
-        <tr>
-          <td class="td-author">
-            <div class="group_member">
-              ${base.gravatar(user.email, 16)}
-              <span class="username user">${h.link_to(user.username, h.url( 'edit_user',user_id=user.user_id))}</span>
-            </div>
-          </td>
-          <td class="fullname">${user.full_name}</td>
-        </tr>
-      %endfor
-      </table>
-    %else:
-      <p class="empty_data">${_('No members yet')}</p>
-    %endif
-  </div>
-</div>

rhodecode/templates/base/flash_msg.html

@@ -1,16 +0,0 b''
-<div class="flash_msg">
-    <% messages = h.flash.pop_messages() %>
-    % if messages:
-        % for message in messages:
-            <div class="alert alert-dismissable alert-${message.category}">
-              <button type="button" class="close" data-dismiss="alert" aria-hidden="true">&times;</button>
-              ${message}
-            </div>
-        % endfor
-    % endif
-    <script>
-    if (typeof jQuery != 'undefined') {
-        $(".alert").alert();
-    }
-    </script>
-</div>

rhodecode/tests/vcsserver.ini

@@ -1,93 +0,0 b''
-################################################################################
-# RhodeCode VCSServer - configuration                                          #
-#                                                                              #
-################################################################################
-
-[DEFAULT]
-host = 127.0.0.1
-port = 9901
-locale = en_US.UTF-8
-# number of worker threads, this should be set based on a formula threadpool=N*6
-# where N is number of RhodeCode Enterprise workers, eg. running 2 instances
-# 8 gunicorn workers each would be 2 * 8 * 6 = 96, threadpool_size = 96
-threadpool_size = 96
-timeout = 0
-
-# cache regions, please don't change
-beaker.cache.regions = repo_object
-beaker.cache.repo_object.type = memorylru
-beaker.cache.repo_object.max_items = 100
-# cache auto-expires after N seconds
-beaker.cache.repo_object.expire = 300
-beaker.cache.repo_object.enabled = true
-
-
-################################
-### LOGGING CONFIGURATION   ####
-################################
-[loggers]
-keys = root, vcsserver, pyro4, beaker
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-#############
-## LOGGERS ##
-#############
-[logger_root]
-level = NOTSET
-handlers = console
-
-[logger_vcsserver]
-level = DEBUG
-handlers =
-qualname = vcsserver
-propagate = 1
-
-[logger_beaker]
-level = DEBUG
-handlers =
-qualname = beaker
-propagate = 1
-
-[logger_pyro4]
-level = DEBUG
-handlers =
-qualname = Pyro4
-propagate = 1
-
-
-##############
-## HANDLERS ##
-##############
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = INFO
-formatter = generic
-
-[handler_file]
-class = FileHandler
-args = ('vcsserver.log', 'a',)
-level = DEBUG
-formatter = generic
-
-[handler_file_rotating]
-class = logging.handlers.TimedRotatingFileHandler
-# 'D', 5 - rotate every 5days
-# you can set 'h', 'midnight'
-args = ('vcsserver.log', 'D', 5, 10,)
-level = DEBUG
-formatter = generic
-
-################
-## FORMATTERS ##
-################
-
-[formatter_generic]
-format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S

rhodecode/tests/vcsserver_pyramid.ini

@@ -1,70 +0,0 b''
-[app:main]
-use = egg:rhodecode-vcsserver
-pyramid.reload_templates = true
-pyramid.default_locale_name = en
-pyramid.includes =
-# cache regions, please don't change
-beaker.cache.regions = repo_object
-beaker.cache.repo_object.type = memorylru
-beaker.cache.repo_object.max_items = 100
-# cache auto-expires after N seconds
-beaker.cache.repo_object.expire = 300
-beaker.cache.repo_object.enabled = true
-locale = en_US.UTF-8
-
-
-[server:main]
-use = egg:waitress#main
-host = 0.0.0.0
-port = %(http_port)s
-
-
-################################
-### LOGGING CONFIGURATION   ####
-################################
-[loggers]
-keys = root, vcsserver, beaker
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-#############
-## LOGGERS ##
-#############
-[logger_root]
-level = NOTSET
-handlers = console
-
-[logger_vcsserver]
-level = DEBUG
-handlers =
-qualname = vcsserver
-propagate = 1
-
-[logger_beaker]
-level = DEBUG
-handlers =
-qualname = beaker
-propagate = 1
-
-
-##############
-## HANDLERS ##
-##############
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = DEBUG
-formatter = generic
-
-################
-## FORMATTERS ##
-################
-
-[formatter_generic]
-format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S

test.ini

@@ -1,716 +0,0 b''
-
-
-################################################################################
-##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
-# The %(here)s variable will be replaced with the parent directory of this file#
-################################################################################
-
-[DEFAULT]
-debug = true
-
-################################################################################
-##                            EMAIL CONFIGURATION                             ##
-## Uncomment and replace with the email address which should receive          ##
-## any error reports after an application crash                               ##
-## Additionally these settings will be used by the RhodeCode mailing system   ##
-################################################################################
-
-## prefix all emails subjects with given prefix, helps filtering out emails
-#email_prefix = [RhodeCode]
-
-## email FROM address all mails will be sent
-#app_email_from = rhodecode-noreply@localhost
-
-## Uncomment and replace with the address which should receive any error report
-## note: using appenlight for error handling doesn't need this to be uncommented
-#email_to = admin@localhost
-
-## in case of Application errors, sent an error email form
-#error_email_from = rhodecode_error@localhost
-
-## additional error message to be send in case of server crash
-#error_message =
-
-
-#smtp_server = mail.server.com
-#smtp_username =
-#smtp_password =
-#smtp_port =
-#smtp_use_tls = false
-#smtp_use_ssl = true
-## Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
-#smtp_auth =
-
-[server:main]
-## COMMON ##
-host = 0.0.0.0
-port = 5000
-
-##################################
-##     WAITRESS WSGI SERVER     ##
-## Recommended for Development  ##
-##################################
-
-use = egg:waitress#main
-## number of worker threads
-threads = 5
-## MAX BODY SIZE 100GB
-max_request_body_size = 107374182400
-## Use poll instead of select, fixes file descriptors limits problems.
-## May not work on old windows systems.
-asyncore_use_poll = true
-
-
-##########################
-## GUNICORN WSGI SERVER ##
-##########################
-## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
-
-#use = egg:gunicorn#main
-## Sets the number of process workers. You must set `instance_id = *`
-## when this option is set to more than one worker, recommended
-## value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers
-## The `instance_id = *` must be set in the [app:main] section below
-#workers = 2
-## number of threads for each of the worker, must be set to 1 for gevent
-## generally recommened to be at 1
-#threads = 1
-## process name
-#proc_name = rhodecode
-## type of worker class, one of sync, gevent
-## recommended for bigger setup is using of of other than sync one
-#worker_class = sync
-## The maximum number of simultaneous clients. Valid only for Gevent
-#worker_connections = 10
-## max number of requests that worker will handle before being gracefully
-## restarted, could prevent memory leaks
-#max_requests = 1000
-#max_requests_jitter = 30
-## amount of time a worker can spend with handling a request before it
-## gets killed and restarted. Set to 6hrs
-#timeout = 21600
-
-## UWSGI ##
-## run with uwsgi --ini-paste-logged <inifile.ini>
-#[uwsgi]
-#socket = /tmp/uwsgi.sock
-#master = true
-#http = 127.0.0.1:5000
-
-## set as deamon and redirect all output to file
-#daemonize = ./uwsgi_rhodecode.log
-
-## master process PID
-#pidfile = ./uwsgi_rhodecode.pid
-
-## stats server with workers statistics, use uwsgitop
-## for monitoring, `uwsgitop 127.0.0.1:1717`
-#stats = 127.0.0.1:1717
-#memory-report = true
-
-## log 5XX errors
-#log-5xx = true
-
-## Set the socket listen queue size.
-#listen = 256
-
-## Gracefully Reload workers after the specified amount of managed requests
-## (avoid memory leaks).
-#max-requests = 1000
-
-## enable large buffers
-#buffer-size=65535
-
-## socket and http timeouts ##
-#http-timeout=3600
-#socket-timeout=3600
-
-## Log requests slower than the specified number of milliseconds.
-#log-slow = 10
-
-## Exit if no app can be loaded.
-#need-app = true
-
-## Set lazy mode (load apps in workers instead of master).
-#lazy = true
-
-## scaling ##
-## set cheaper algorithm to use, if not set default will be used
-#cheaper-algo = spare
-
-## minimum number of workers to keep at all times
-#cheaper = 1
-
-## number of workers to spawn at startup
-#cheaper-initial = 1
-
-## maximum number of workers that can be spawned
-#workers = 4
-
-## how many workers should be spawned at a time
-#cheaper-step = 1
-
-## prefix middleware for RhodeCode, disables force_https flag.
-## recommended when using proxy setup.
-## allows to set RhodeCode under a prefix in server.
-## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
-## optionally set prefix like: `prefix = /<your-prefix>`
-[filter:proxy-prefix]
-use = egg:PasteDeploy#prefix
-prefix = /
-
-[app:main]
-is_test = True
-use = egg:rhodecode-enterprise-ce
-
-## enable proxy prefix middleware, defined above
-#filter-with = proxy-prefix
-
-
-## RHODECODE PLUGINS ##
-rhodecode.includes = rhodecode.api
-
-# api prefix url
-rhodecode.api.url = /_admin/api
-
-
-## END RHODECODE PLUGINS ##
-
-## encryption key used to encrypt social plugin tokens,
-## remote_urls with credentials etc, if not set it defaults to
-## `beaker.session.secret`
-#rhodecode.encrypted_values.secret =
-
-## decryption strict mode (enabled by default). It controls if decryption raises
-## `SignatureVerificationError` in case of wrong key, or damaged encryption data.
-#rhodecode.encrypted_values.strict = false
-
-## return gzipped responses from Rhodecode (static files/application)
-gzip_responses = false
-
-## autogenerate javascript routes file on startup
-generate_js_files = false
-
-## Optional Languages
-## en(default), be, de, es, fr, it, ja, pl, pt, ru, zh
-lang = en
-
-## perform a full repository scan on each server start, this should be
-## set to false after first startup, to allow faster server restarts.
-startup.import_repos = true
-
-## Uncomment and set this path to use archive download cache.
-## Once enabled, generated archives will be cached at this location
-## and served from the cache during subsequent requests for the same archive of
-## the repository.
-#archive_cache_dir = /tmp/tarballcache
-
-## change this to unique ID for security
-app_instance_uuid = rc-production
-
-## cut off limit for large diffs (size in bytes)
-cut_off_limit_diff = 1024000
-cut_off_limit_file = 256000
-
-## use cache version of scm repo everywhere
-vcs_full_cache = false
-
-## force https in RhodeCode, fixes https redirects, assumes it's always https
-## Normally this is controlled by proper http flags sent from http server
-force_https = false
-
-## use Strict-Transport-Security headers
-use_htsts = false
-
-## number of commits stats will parse on each iteration
-commit_parse_limit = 25
-
-## 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 = --all
-
-# Set to true if your repos are exposed using the dumb protocol
-git_update_server_info = false
-
-## RSS/ATOM feed options
-rss_cut_off_limit = 256000
-rss_items_per_page = 10
-rss_include_diff = false
-
-## 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.rhodecode.org/{gistid}. Empty means use the internal
-## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
-gist_alias_url =
-
-## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
-## used for access.
-## Adding ?auth_token = <token> to the url authenticates this request as if it
-## came from the the logged in user who own this authentication token.
-##
-## Syntax is <ControllerClass>:<function_pattern>.
-## To enable access to raw_files put `FilesController:raw`.
-## To enable access to patches add `ChangesetController:changeset_patch`.
-## The list should be "," separated and on a single line.
-##
-## Recommended controllers to enable:
-#    ChangesetController:changeset_patch,
-#    ChangesetController:changeset_raw,
-#    FilesController:raw,
-#    FilesController:archivefile,
-#    GistsController:*,
-api_access_controllers_whitelist =
-
-## 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 = UTF-8
-
-## instance-id prefix
-## a prefix key for this instance used for cache invalidation when running
-## multiple instances of rhodecode, make sure it's globally unique for
-## all running rhodecode instances. Leave empty if you don't use it
-instance_id =
-
-## Fallback authentication plugin. Set this to a plugin ID to force the usage
-## of an authentication plugin also if it is disabled by it's settings.
-## This could be useful if you are unable to log in to the system due to broken
-## authentication settings. Then you can enable e.g. the internal rhodecode auth
-## module to log in again and fix the settings.
-##
-## Available builtin plugin IDs (hash is part of the ID):
-## egg:rhodecode-enterprise-ce#rhodecode
-## egg:rhodecode-enterprise-ce#pam
-## egg:rhodecode-enterprise-ce#ldap
-## egg:rhodecode-enterprise-ce#jasig_cas
-## egg:rhodecode-enterprise-ce#headers
-## egg:rhodecode-enterprise-ce#crowd
-#rhodecode.auth_plugin_fallback = egg:rhodecode-enterprise-ce#rhodecode
-
-## alternative return HTTP header for failed authentication. Default HTTP
-## response is 401 HTTPUnauthorized. Currently HG clients have troubles with
-## handling that causing a series of failed authentication calls.
-## Set this variable to 403 to return HTTPForbidden, or any other HTTP code
-## This will be served instead of default 401 on bad authnetication
-auth_ret_code =
-
-## use special detection method when serving auth_ret_code, instead of serving
-## ret_code directly, use 401 initially (Which triggers credentials prompt)
-## and then serve auth_ret_code to clients
-auth_ret_code_detection = false
-
-## 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
-
-## generated license token, goto license page in RhodeCode settings to obtain
-## new token
-license_token = abra-cada-bra1-rce3
-
-## supervisor connection uri, for managing supervisor and logs.
-supervisor.uri =
-## supervisord group name/id we only want this RC instance to handle
-supervisor.group_id = dev
-
-## Display extended labs settings
-labs_settings_active = true
-
-####################################
-###        CELERY CONFIG        ####
-####################################
-use_celery = false
-broker.host = localhost
-broker.vhost = rabbitmqhost
-broker.port = 5672
-broker.user = rabbitmq
-broker.password = qweqwe
-
-celery.imports = rhodecode.lib.celerylib.tasks
-
-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.log.file = celeryd.log
-celeryd.log.level = debug
-celeryd.max.tasks.per.child = 1
-
-## tasks will never be sent to the queue, but executed locally instead.
-celery.always.eager = false
-
-####################################
-###         BEAKER CACHE        ####
-####################################
-# default cache dir for templates.  Putting this into a ramdisk
-## can boost performance, eg. %(here)s/data_ramdisk
-cache_dir = %(here)s/data
-
-## locking and default file storage for Beaker. Putting this into a ramdisk
-## can boost performance, eg. %(here)s/data_ramdisk/cache/beaker_data
-beaker.cache.data_dir = %(here)s/rc/data/cache/beaker_data
-beaker.cache.lock_dir = %(here)s/rc/data/cache/beaker_lock
-
-beaker.cache.regions = super_short_term, short_term, long_term, sql_cache_short, auth_plugins, repo_cache_long
-
-beaker.cache.super_short_term.type = memory
-beaker.cache.super_short_term.expire = 1
-beaker.cache.super_short_term.key_length = 256
-
-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 = 1
-beaker.cache.sql_cache_short.key_length = 256
-
-## default is memory cache, configure only if required
-## using multi-node or multi-worker setup
-#beaker.cache.auth_plugins.type = ext:database
-#beaker.cache.auth_plugins.lock_dir = %(here)s/data/cache/auth_plugin_lock
-#beaker.cache.auth_plugins.url = postgresql://postgres:secret@localhost/rhodecode
-#beaker.cache.auth_plugins.url = mysql://root:secret@127.0.0.1/rhodecode
-#beaker.cache.auth_plugins.sa.pool_recycle = 3600
-#beaker.cache.auth_plugins.sa.pool_size = 10
-#beaker.cache.auth_plugins.sa.max_overflow = 0
-
-beaker.cache.repo_cache_long.type = memorylru_base
-beaker.cache.repo_cache_long.max_items = 4096
-beaker.cache.repo_cache_long.expire = 2592000
-
-## default is memorylru_base cache, configure only if required
-## using multi-node or multi-worker setup
-#beaker.cache.repo_cache_long.type = ext:memcached
-#beaker.cache.repo_cache_long.url = localhost:11211
-#beaker.cache.repo_cache_long.expire = 1209600
-#beaker.cache.repo_cache_long.key_length = 256
-
-####################################
-###       BEAKER SESSION        ####
-####################################
-
-## .session.type is type of storage options for the session, current allowed
-## types are file, ext:memcached, ext:database, and memory (default).
-beaker.session.type = file
-beaker.session.data_dir = %(here)s/rc/data/sessions/data
-
-## db based session, fast, and allows easy management over logged in users
-#beaker.session.type = ext:database
-#beaker.session.table_name = db_session
-#beaker.session.sa.url = postgresql://postgres:secret@localhost/rhodecode
-#beaker.session.sa.url = mysql://root:secret@127.0.0.1/rhodecode
-#beaker.session.sa.pool_recycle = 3600
-#beaker.session.sa.echo = false
-
-beaker.session.key = rhodecode
-beaker.session.secret = test-rc-uytcxaz
-beaker.session.lock_dir = %(here)s/rc/data/sessions/lock
-
-## Secure encrypted cookie. Requires AES and AES python libraries
-## you must disable beaker.session.secret to use this
-#beaker.session.encrypt_key = <key_for_encryption>
-#beaker.session.validate_key = <validation_key>
-
-## sets session as invalid(also logging out user) if it haven not been
-## accessed for given amount of time in seconds
-beaker.session.timeout = 2592000
-beaker.session.httponly = true
-## Path to use for the cookie.
-#beaker.session.cookie_path = /<your-prefix>
-
-## uncomment for https secure cookie
-beaker.session.secure = false
-
-## auto save the session to not to use .save()
-beaker.session.auto = false
-
-## default cookie expiration time in seconds, set to `true` to set expire
-## at browser close
-#beaker.session.cookie_expires = 3600
-
-###################################
-## SEARCH INDEXING CONFIGURATION ##
-###################################
-## Full text search indexer is available in rhodecode-tools under
-## `rhodecode-tools index` command
-
-# WHOOSH Backend, doesn't require additional services to run
-# it works good with few dozen repos
-search.module = rhodecode.lib.index.whoosh
-search.location = %(here)s/data/index
-
-########################################
-###    CHANNELSTREAM CONFIG         ####
-########################################
-## channelstream enables persistent connections and live notification
-## in the system. It's also used by the chat system
-
-channelstream.enabled = false
-# location of channelstream server on the backend
-channelstream.server = 127.0.0.1:9800
-## location of the channelstream server from outside world
-## most likely this would be an http server special backend URL, that handles
-## websocket connections see nginx example for config
-channelstream.ws_url = ws://rhodecode.yourserver.com/_channelstream
-channelstream.secret = secret
-channelstream.history.location = %(here)s/channelstream_history
-
-
-###################################
-##       APPENLIGHT CONFIG       ##
-###################################
-
-## Appenlight is tailored to work with RhodeCode, see
-## http://appenlight.com for details how to obtain an account
-
-## appenlight integration enabled
-appenlight = false
-
-appenlight.server_url = https://api.appenlight.com
-appenlight.api_key = YOUR_API_KEY
-#appenlight.transport_config = https://api.appenlight.com?threaded=1&timeout=5
-
-# used for JS client
-appenlight.api_public_key = YOUR_API_PUBLIC_KEY
-
-## TWEAK AMOUNT OF INFO SENT HERE
-
-## enables 404 error logging (default False)
-appenlight.report_404 = false
-
-## time in seconds after request is considered being slow (default 1)
-appenlight.slow_request_time = 1
-
-## record slow requests in application
-## (needs to be enabled for slow datastore recording and time tracking)
-appenlight.slow_requests = true
-
-## enable hooking to application loggers
-appenlight.logging = true
-
-## minimum log level for log capture
-appenlight.logging.level = WARNING
-
-## send logs only from erroneous/slow requests
-## (saves API quota for intensive logging)
-appenlight.logging_on_error = false
-
-## list of additonal keywords that should be grabbed from environ object
-## can be string with comma separated list of words in lowercase
-## (by default client will always send following info:
-## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that
-## start with HTTP* this list be extended with additional keywords here
-appenlight.environ_keys_whitelist =
-
-## list of keywords that should be blanked from request object
-## can be string with comma separated list of words in lowercase
-## (by default client will always blank keys that contain following words
-## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'
-## this list be extended with additional keywords set here
-appenlight.request_keys_blacklist =
-
-## list of namespaces that should be ignores when gathering log entries
-## can be string with comma separated list of namespaces
-## (by default the client ignores own entries: appenlight_client.client)
-appenlight.log_namespace_blacklist =
-
-
-################################################################################
-## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
-## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
-## execute malicious code after an exception is raised.                       ##
-################################################################################
-set debug = false
-
-
-##############
-## STYLING  ##
-##############
-debug_style = false
-
-#########################################################
-### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
-#########################################################
-#sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode_test.db
-#sqlalchemy.db1.url = postgresql://postgres:qweqwe@localhost/rhodecode_test
-#sqlalchemy.db1.url = mysql://root:qweqwe@localhost/rhodecode_test
-sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode_test.db
-
-# see sqlalchemy docs for other advanced settings
-
-## print the sql statements to output
-sqlalchemy.db1.echo = false
-## recycle the connections after this ammount of seconds
-sqlalchemy.db1.pool_recycle = 3600
-sqlalchemy.db1.convert_unicode = true
-
-## the number of connections to keep open inside the connection pool.
-## 0 indicates no limit
-#sqlalchemy.db1.pool_size = 5
-
-## the number of connections to allow in connection pool "overflow", that is
-## connections that can be opened above and beyond the pool_size setting,
-## which defaults to five.
-#sqlalchemy.db1.max_overflow = 10
-
-
-##################
-### VCS CONFIG ###
-##################
-vcs.server.enable = true
-vcs.server = localhost:9901
-
-## Web server connectivity protocol, responsible for web based VCS operatations
-## Available protocols are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
-vcs.server.protocol = pyro4
-
-## Push/Pull operations protocol, available options are:
-## `pyro4` - using pyro4 server
-## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
-## `vcsserver.scm_app` - internal app (EE only)
-vcs.scm_app_implementation = pyro4
-
-## Push/Pull operations hooks protocol, available options are:
-## `pyro4` - using pyro4 server
-## `http` - using http-rpc backend
-vcs.hooks.protocol = pyro4
-
-vcs.server.log_level = debug
-## Start VCSServer with this instance as a subprocess, usefull for development
-vcs.start_server = true
-
-## List of enabled VCS backends, available options are:
-## `hg`  - mercurial
-## `git` - git
-## `svn` - subversion
-vcs.backends = hg, git, svn
-
-vcs.connection_timeout = 3600
-## Compatibility version when creating SVN repositories. Defaults to newest version when commented out.
-## Available options are: pre-1.4-compatible, pre-1.5-compatible, pre-1.6-compatible, pre-1.8-compatible
-#vcs.svn.compatible_version = pre-1.8-compatible
-
-
-############################################################
-### Subversion proxy support (mod_dav_svn)               ###
-### Maps RhodeCode repo groups into SVN paths for Apache ###
-############################################################
-## Enable or disable the config file generation.
-svn.proxy.generate_config = false
-## Generate config file with `SVNListParentPath` set to `On`.
-svn.proxy.list_parent_path = true
-## Set location and file name of generated config file.
-svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
-## File system path to the directory containing the repositories served by
-## RhodeCode.
-svn.proxy.parent_path_root = /path/to/repo_store
-## Used as a prefix to the <Location> block in the generated config file. In
-## most cases it should be set to `/`.
-svn.proxy.location_root = /
-
-
-################################
-### LOGGING CONFIGURATION   ####
-################################
-[loggers]
-keys = root, routes, rhodecode, sqlalchemy, beaker, pyro4, templates
-
-[handlers]
-keys = console, console_sql
-
-[formatters]
-keys = generic, color_formatter, color_formatter_sql
-
-#############
-## LOGGERS ##
-#############
-[logger_root]
-level = NOTSET
-handlers = console
-
-[logger_routes]
-level = DEBUG
-handlers =
-qualname = routes.middleware
-## "level = DEBUG" logs the route matched and routing variables.
-propagate = 1
-
-[logger_beaker]
-level = DEBUG
-handlers =
-qualname = beaker.container
-propagate = 1
-
-[logger_pyro4]
-level = DEBUG
-handlers =
-qualname = Pyro4
-propagate = 1
-
-[logger_templates]
-level = INFO
-handlers =
-qualname = pylons.templating
-propagate = 1
-
-[logger_rhodecode]
-level = DEBUG
-handlers =
-qualname = rhodecode
-propagate = 1
-
-[logger_sqlalchemy]
-level = ERROR
-handlers = console_sql
-qualname = sqlalchemy.engine
-propagate = 0
-
-##############
-## HANDLERS ##
-##############
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = DEBUG
-formatter = generic
-
-[handler_console_sql]
-class = StreamHandler
-args = (sys.stderr,)
-level = WARN
-formatter = generic
-
-################
-## FORMATTERS ##
-################
-
-[formatter_generic]
-class = rhodecode.lib.logging_formatter.Pyro4AwareFormatter
-format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S
-
-[formatter_color_formatter]
-class = rhodecode.lib.logging_formatter.ColorFormatter
-format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S
-
-[formatter_color_formatter_sql]
-class = rhodecode.lib.logging_formatter.ColorFormatterSql
-format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S