release: merge default to stable for 0.7.0

kallithea/alembic/versions/7ba0d2cad930_hooks_migrate_internal_hooks_to_.py

@@ -0,0 +1,57 b''
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""hooks: migrate internal hooks to kallithea namespace
+
+Revision ID: 7ba0d2cad930
+Revises: f62826179f39
+Create Date: 2021-01-11 00:10:13.576586
+
+"""
+
+# The following opaque hexadecimal identifiers ("revisions") are used
+# by Alembic to track this migration script and its relations to others.
+revision = '7ba0d2cad930'
+down_revision = 'f62826179f39'
+branch_labels = None
+depends_on = None
+
+from alembic import op
+from sqlalchemy import MetaData, Table
+
+from kallithea.model import db
+
+
+meta = MetaData()
+
+
+def upgrade():
+    meta.bind = op.get_bind()
+    ui = Table(db.Ui.__tablename__, meta, autoload=True)
+
+    ui.update(values={
+        'ui_key': 'changegroup.kallithea_update',
+        'ui_value': 'python:',  # value in db isn't used
+    }).where(ui.c.ui_key == 'changegroup.update').execute()
+    ui.update(values={
+        'ui_key': 'changegroup.kallithea_repo_size',
+        'ui_value': 'python:',  # value in db isn't used
+    }).where(ui.c.ui_key == 'changegroup.repo_size').execute()
+
+    # 642847355a10 moved these hooks out of db - remove old entries
+    ui.delete().where(ui.c.ui_key == 'changegroup.push_logger').execute()
+    ui.delete().where(ui.c.ui_key == 'outgoing.pull_logger').execute()
+
+
+def downgrade():
+    pass

kallithea/alembic/versions/f62826179f39_add_unique_constraint_on_.py

@@ -0,0 +1,73 b''
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""add unique constraint on PullRequestReviewer
+
+Revision ID: f62826179f39
+Revises: a0a1bf09c143
+Create Date: 2020-06-15 12:30:37.420321
+
+"""
+
+# The following opaque hexadecimal identifiers ("revisions") are used
+# by Alembic to track this migration script and its relations to others.
+revision = 'f62826179f39'
+down_revision = 'a0a1bf09c143'
+branch_labels = None
+depends_on = None
+
+import sqlalchemy as sa
+from alembic import op
+
+from kallithea.model import db
+
+
+def upgrade():
+    session = sa.orm.session.Session(bind=op.get_bind())
+
+    # there may be existing duplicates in the database, remove them first
+
+    seen = set()
+    # duplicate_values contains one copy of each duplicated pair
+    duplicate_values = (
+        session
+        .query(db.PullRequestReviewer.pull_request_id, db.PullRequestReviewer.user_id)
+        .group_by(db.PullRequestReviewer.pull_request_id, db.PullRequestReviewer.user_id)
+        .having(sa.func.count(db.PullRequestReviewer.pull_request_reviewers_id) > 1)
+    )
+
+    for pull_request_id, user_id in duplicate_values:
+        # duplicate_occurrences contains all db records of the duplicate_value
+        # currently being processed
+        duplicate_occurrences = (
+            session
+            .query(db.PullRequestReviewer)
+            .filter(db.PullRequestReviewer.pull_request_id == pull_request_id)
+            .filter(db.PullRequestReviewer.user_id == user_id)
+        )
+        for prr in duplicate_occurrences:
+            if (pull_request_id, user_id) in seen:
+                session.delete(prr)
+            else:
+                seen.add((pull_request_id, user_id))
+
+    session.commit()
+
+    # after deleting all duplicates, add the unique constraint
+    with op.batch_alter_table('pull_request_reviewers', schema=None) as batch_op:
+        batch_op.create_unique_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), ['pull_request_id', 'user_id'])
+
+
+def downgrade():
+    with op.batch_alter_table('pull_request_reviewers', schema=None) as batch_op:
+        batch_op.drop_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), type_='unique')

.coveragerc

@@ -8,9 +8,6 b' omit ='
     kallithea/lib/dbmigrate/*
     # the tests themselves should not be part of the coverage report
     kallithea/tests/*
-    # the scm hooks are not run in the kallithea process
-    kallithea/config/post_receive_tmpl.py
-    kallithea/config/pre_receive_tmpl.py
 
 # same omit lines should be present in sections 'run' and 'report'
 [report]
@@ -23,9 +20,6 b' omit ='
     kallithea/lib/dbmigrate/*
     # the tests themselves should not be part of the coverage report
     kallithea/tests/*
-    # the scm hooks are not run in the kallithea process
-    kallithea/config/post_receive_tmpl.py
-    kallithea/config/pre_receive_tmpl.py
 
 [paths]
 source =

.hgignore

@@ -10,16 +10,15 b' syntax: glob'
 *.rej
 *.bak
 .eggs/
-tarballcache/
 
 syntax: regexp
-^rcextensions
-^build
-^dist/
-^docs/build/
-^docs/_build/
+^extensions\.py$
+^build$
+^dist$
+^docs/build$
+^docs/_build$
 ^data$
-^sql_dumps/
+^sql_dumps$
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
@@ -48,8 +47,13 b' syntax: regexp'
 ^test\.db$
 ^Kallithea\.egg-info$
 ^my\.ini$
-^fabfile.py
+^fabfile\.py$
 ^\.idea$
 ^\.cache$
 ^\.pytest_cache$
+^venv$
 /__pycache__$
+^deps\.dot$
+^deps\.svg$
+^deps\.txt$
+^\.pytype/

CONTRIBUTORS

@@ -1,19 +1,26 b''
 List of contributors to Kallithea project:
 
-    Thomas De Schampheleire <[e-mail]> 2014-2020
-    Mads Kiilerich <[e-mail]> 2016-2020
+    Thomas De Schampheleire <[e-mail]> 2014-2021
+    Mads Kiilerich <[e-mail]> 2016-2021
+    ssantos <[e-mail]> 2018-2021
+    Private <[e-mail]> 2019-2021
+    Étienne Gilli <[e-mail]> 2020-2021
+    fresh <[e-mail]> 2020-2021
+    robertus <[e-mail]> 2020-2021
+    Eugenia Russell <[e-mail]> 2021
+    Michalis <[e-mail]> 2021
+    vs <[e-mail]> 2021
+    Александр <[e-mail]> 2021
     Asterios Dimitriou <[e-mail]> 2016-2017 2020
     Allan Nordhøy <[e-mail]> 2017-2020
     Anton Schur <[e-mail]> 2017 2020
-    ssantos <[e-mail]> 2018-2020
     Manuel Jacob <[e-mail]> 2019-2020
-    Private <[e-mail]> 2019-2020
+    Artem <[e-mail]> 2020
     David Ignjić <[e-mail]> 2020
     Dennis Fink <[e-mail]> 2020
-    Étienne Gilli <[e-mail]> 2020
     J. Lavoie <[e-mail]> 2020
-    robertus <[e-mail]> 2020
     Ross Thomas <[e-mail]> 2020
+    Tim Ooms <[e-mail]> 2020
     Andrej Shadura <[e-mail]> 2012 2014-2017 2019
     Étienne Gilli <[e-mail]> 2015-2017 2019
     Adi Kriegisch <[e-mail]> 2019

MANIFEST.in

@@ -18,7 +18,6 b' recursive-include docs *'
 recursive-include init.d *
 recursive-include kallithea/alembic *
 include           kallithea/bin/ldap_sync.conf
-include           kallithea/lib/paster_commands/template.ini.mako
 recursive-include kallithea/front-end *
 recursive-include kallithea/i18n *
 recursive-include kallithea/public *

README.rst

@@ -74,8 +74,8 b' Kallithea features'
   web interface using simple editor or upload binary files using simple form.
 - Powerful pull request driven review system with inline commenting, changeset
   statuses, and notification system.
-- Importing and syncing repositories from remote locations for Git_, Mercurial_
-  and Subversion.
+- Importing and syncing repositories from remote locations for Git_ and
+  Mercurial_.
 - Mako templates let you customize the look and feel of the application.
 - Beautiful diffs, annotations and source code browsing all colored by
   pygments. Raw diffs are made in Git-diff format for both VCS systems,
@@ -175,7 +175,6 b' of Kallithea.'
 .. _Mercurial: http://mercurial.selenic.com/
 .. _Bitbucket: http://bitbucket.org/
 .. _GitHub: http://github.com/
-.. _Subversion: http://subversion.tigris.org/
 .. _Git: http://git-scm.com/
 .. _Celery: http://celeryproject.org/
 .. _Software Freedom Conservancy: http://sfconservancy.org/

dev_requirements.txt

@@ -1,9 +1,9 b''
-pytest >= 4.6.6, < 5.4
+pytest >= 4.6.6, < 5.5
 pytest-sugar >= 0.9.2, < 0.10
 pytest-benchmark >= 3.2.2, < 3.3
 pytest-localserver >= 0.5.0, < 0.6
 mock >= 3.0.0, < 4.1
-Sphinx >= 1.8.0, < 2.4
+Sphinx >= 1.8.0, < 3.1
 WebTest >= 2.0.6, < 2.1
-isort == 4.3.21
-pyflakes == 2.1.1
+isort == 5.1.2
+pyflakes == 2.2.0

development.ini

@@ -67,11 +67,11 b' smtp_use_tls = false'
 host = 0.0.0.0
 port = 5000
 
-## WAITRESS ##
+## Gearbox serve uses the Waitress web server ##
 use = egg:waitress#main
-## number of worker threads
+## avoid multi threading
 threads = 1
-## MAX BODY SIZE 100GB
+## allow push of repos bigger than the default of 1 GB
 max_request_body_size = 107374182400
 ## use poll instead of select, fixes fd limits, may not work on old
 ## windows systems.
@@ -81,6 +81,7 b' max_request_body_size = 107374182400'
 #[filter:proxy-prefix]
 #use = egg:PasteDeploy#prefix
 #prefix = /<your-prefix>
+#translate_forwarded_server = False
 
 [app:main]
 use = egg:kallithea
@@ -102,7 +103,7 b' cache_dir = %(here)s/data'
 index_dir = %(here)s/data/index
 
 ## uncomment and set this path to use archive download cache
-archive_cache_dir = %(here)s/tarballcache
+archive_cache_dir = %(here)s/data/tarballcache
 
 ## change this to unique ID for security
 #app_instance_uuid = VERY-SECRET
@@ -111,11 +112,17 b' app_instance_uuid = development-not-secr'
 ## cut off limit for large diffs (size in bytes)
 cut_off_limit = 256000
 
-## force https in Kallithea, fixes https redirects, assumes it's always https
-force_https = false
+## WSGI environment variable to get the IP address of the client (default REMOTE_ADDR)
+#remote_addr_variable = HTTP_X_FORWARDED_FOR
+
+## WSGI environment variable to get the protocol (http or https) of the client connection (default wsgi.url_scheme)
+#url_scheme_variable = HTTP_X_FORWARDED_PROTO
 
-## use Strict-Transport-Security headers
-use_htsts = false
+## always pretend the client connected using HTTPS (default false)
+#force_https = true
+
+## use Strict-Transport-Security headers (default false)
+#use_htsts = true
 
 ## number of commits stats will parse on each iteration
 commit_parse_limit = 25
@@ -259,15 +266,8 b' use_celery = false'
 ## Example: use the message queue on the local virtual host 'kallitheavhost' as the RabbitMQ user 'kallithea':
 celery.broker_url = amqp://kallithea:thepassword@localhost:5672/kallitheavhost
 
-celery.result_backend = db+sqlite:///celery-results.db
-
-#celery.amqp.task.result.expires = 18000
-
 celery.worker_concurrency = 2
-celery.worker_max_tasks_per_child = 1
-
-## If true, tasks will never be sent to the queue, but executed locally instead.
-celery.task_always_eager = false
+celery.worker_max_tasks_per_child = 100
 
 ####################################
 ##          BEAKER CACHE          ##
@@ -346,7 +346,6 b' get trace_errors.smtp_username = smtp_us'
 get trace_errors.smtp_password = smtp_password
 get trace_errors.smtp_use_tls = smtp_use_tls
 
-
 ##################################
 ##        LOGVIEW CONFIG        ##
 ##################################
@@ -359,10 +358,10 b' logview.pylons.util = #eee'
 ##      DB CONFIG      ##
 #########################
 
-## SQLITE [default]
 sqlalchemy.url = sqlite:///%(here)s/kallithea.db?timeout=60
-
-## see sqlalchemy docs for other backends
+#sqlalchemy.url = postgresql://kallithea:password@localhost/kallithea
+#sqlalchemy.url = mysql://kallithea:password@localhost/kallithea?charset=utf8mb4
+## Note: the mysql:// prefix should also be used for MariaDB
 
 sqlalchemy.pool_recycle = 3600
 

docs/conf.py

@@ -14,7 +14,7 b''
 import os
 import sys
 
-from kallithea import __version__
+import kallithea
 
 
 # If extensions (or modules to document with autodoc) are in another directory,
@@ -47,7 +47,7 b" master_doc = 'index'"
 
 # General information about the project.
 project = 'Kallithea'
-copyright = '2010-2020 by various authors, licensed as GPLv3.'
+copyright = '2010-2021 by various authors, licensed as GPLv3.'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -56,9 +56,9 b" copyright = '2010-2020 by various author"
 # The short X.Y version.
 root = os.path.dirname(os.path.dirname(__file__))
 sys.path.append(root)
-version = __version__
+version = kallithea.__version__
 # The full version, including alpha/beta/rc tags.
-release = __version__
+release = kallithea.__version__
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/contributing.rst

@@ -26,12 +26,13 b' for more details.'
 Getting started
 ---------------
 
-To get started with Kallithea development::
+To get started with Kallithea development run the following commands in your
+bash shell::
 
         hg clone https://kallithea-scm.org/repos/kallithea
         cd kallithea
-        python3 -m venv ../kallithea-venv
-        source ../kallithea-venv/bin/activate
+        python3 -m venv venv
+        . venv/bin/activate
         pip install --upgrade pip setuptools
         pip install --upgrade -e . -r dev_requirements.txt python-ldap python-pam
         kallithea-cli config-create my.ini
@@ -71,6 +72,94 b' review and inclusion, via the mailing li'
 .. _contributing-tests:
 
 
+Internal dependencies
+---------------------
+
+We try to keep the code base clean and modular and avoid circular dependencies.
+Code should only invoke code in layers below itself.
+
+Imports should import whole modules ``from`` their parent module, perhaps
+``as`` a shortened name. Avoid imports ``from`` modules.
+
+To avoid cycles and partially initialized modules, ``__init__.py`` should *not*
+contain any non-trivial imports. The top level of a module should *not* be a
+facade for the module functionality.
+
+Common code for a module is often in ``base.py``.
+
+The important part of the dependency graph is approximately linear. In the
+following list, modules may only depend on modules below them:
+
+``tests``
+  Just get the job done - anything goes.
+
+``bin/`` & ``config/`` & ``alembic/``
+  The main entry points, defined in ``setup.py``. Note: The TurboGears template
+  use ``config`` for the high WSGI application - this is not for low level
+  configuration.
+
+``controllers/``
+  The top level web application, with TurboGears using the ``root`` controller
+  as entry point, and ``routing`` dispatching to other controllers.
+
+``templates/**.html``
+  The "view", rendering to HTML. Invoked by controllers which can pass them
+  anything from lower layers - especially ``helpers`` available as ``h`` will
+  cut through all layers, and ``c`` gives access to global variables.
+
+``lib/helpers.py``
+  High level helpers, exposing everything to templates as ``h``. It depends on
+  everything and has a huge dependency chain, so it should not be used for
+  anything else. TODO.
+
+``controllers/base.py``
+  The base class of controllers, with lots of model knowledge.
+
+``lib/auth.py``
+  All things related to authentication. TODO.
+
+``lib/utils.py``
+  High level utils with lots of model knowledge. TODO.
+
+``lib/hooks.py``
+  Hooks into "everything" to give centralized logging to database, cache
+  invalidation, and extension handling. TODO.
+
+``model/``
+  Convenience business logic wrappers around database models.
+
+``model/db.py``
+  Defines the database schema and provides some additional logic.
+
+``model/scm.py``
+  All things related to anything. TODO.
+
+SQLAlchemy
+  Database session and transaction in thread-local variables.
+
+``lib/utils2.py``
+  Low level utils specific to Kallithea.
+
+``lib/webutils.py``
+  Low level generic utils with awareness of the TurboGears environment.
+
+TurboGears
+  Request, response and state like i18n gettext in thread-local variables.
+  External dependency with global state - usage should be minimized.
+
+``lib/vcs/``
+  Previously an independent library. No awareness of web, database, or state.
+
+``lib/*``
+  Various "pure" functionality not depending on anything else.
+
+``__init__``
+  Very basic Kallithea constants - some of them are set very early based on ``.ini``.
+
+This is not exactly how it is right now, but we aim for something like that.
+Especially the areas marked as TODO have some problems that need untangling.
+
+
 Running tests
 -------------
 
@@ -84,6 +173,17 b' Note that on unix systems, the temporary'
 and the test suite creates repositories in the temporary directory. Linux
 systems with /tmp mounted noexec will thus fail.
 
+Tests can be run on PostgreSQL like::
+
+    sudo -u postgres createuser 'kallithea-test' --pwprompt  # password password
+    sudo -u postgres createdb 'kallithea-test' --owner 'kallithea-test'
+    REUSE_TEST_DB='postgresql://kallithea-test:password@localhost/kallithea-test' py.test
+
+Tests can be run on MariaDB/MySQL like::
+
+    echo "GRANT ALL PRIVILEGES ON \`kallithea-test\`.* TO 'kallithea-test'@'localhost' IDENTIFIED BY 'password'" | sudo -u mysql mysql
+    TEST_DB='mysql://kallithea-test:password@localhost/kallithea-test?charset=utf8mb4' py.test
+
 You can also use ``tox`` to run the tests with all supported Python versions.
 
 When running tests, Kallithea generates a `test.ini` based on template values
@@ -147,8 +247,9 b' committer/contributor and under GPLv3 un'
 lot about preservation of copyright and license information for existing code
 that is brought into the project.
 
-Contributions will be accepted in most formats -- such as commits hosted on your own Kallithea instance, or patches sent by
-email to the `kallithea-general`_ mailing list.
+Contributions will be accepted in most formats -- such as commits hosted on your
+own Kallithea instance, or patches sent by email to the `kallithea-general`_
+mailing list.
 
 Make sure to test your changes both manually and with the automatic tests
 before posting.

docs/index.rst

@@ -81,7 +81,6 b' Developer guide'
 .. _python: http://www.python.org/
 .. _django: http://www.djangoproject.com/
 .. _mercurial: https://www.mercurial-scm.org/
-.. _subversion: http://subversion.tigris.org/
 .. _git: http://git-scm.com/
 .. _celery: http://celeryproject.org/
 .. _Sphinx: http://sphinx.pocoo.org/

docs/installation.rst

@@ -19,12 +19,12 b' The following describes three different '
   installations side by side or remove it entirely by just removing the
   virtualenv directory) and does not require root privileges.
 
-- :ref:`installation-without-virtualenv`: The alternative method of installing
-  a Kallithea release is using standard pip. The package will be installed in
-  the same location as all other Python packages you have ever installed. As a
-  result, removing it is not as straightforward as with a virtualenv, as you'd
-  have to remove its dependencies manually and make sure that they are not
-  needed by other packages.
+- Kallithea can also be installed with plain pip - globally or with ``--user``
+  or similar. The package will be installed in the same location as all other
+  Python packages you have ever installed. As a result, removing it is not as
+  straightforward as with a virtualenv, as you'd have to remove its
+  dependencies manually and make sure that they are not needed by other
+  packages. We recommend using virtualenv.
 
 Regardless of the installation method you may need to make sure you have
 appropriate development packages installed, as installation of some of the
@@ -49,17 +49,24 b' Installation from repository source'
 -----------------------------------
 
 To install Kallithea in a virtualenv using the stable branch of the development
-repository, follow the instructions below::
+repository, use the following commands in your bash shell::
 
         hg clone https://kallithea-scm.org/repos/kallithea -u stable
         cd kallithea
-        python3 -m venv ../kallithea-venv
-        . ../kallithea-venv/bin/activate
+        python3 -m venv venv
+        . venv/bin/activate
         pip install --upgrade pip setuptools
         pip install --upgrade -e .
         python3 setup.py compile_catalog   # for translation of the UI
 
-You can now proceed to :ref:`setup`.
+.. note::
+   This will install all Python dependencies into the virtualenv. Kallithea
+   itself will however only be installed as a pointer to the source location.
+   The source clone must thus be kept in the same location, and it shouldn't be
+   updated to other revisions unless you want to upgrade. Edits in the source
+   tree will have immediate impact (possibly after a restart of the service).
+
+You can now proceed to :ref:`prepare-front-end-files`.
 
 .. _installation-virtualenv:
 
@@ -73,27 +80,30 b' main Python installation and other appli'
 problematic when upgrading the system or Kallithea.
 An additional benefit of virtualenv is that it doesn't require root privileges.
 
-- Assuming you have installed virtualenv, create a new virtual environment
-  for example, in `/srv/kallithea/venv`, using the venv command::
+- Don't install as root - install as a dedicated user like ``kallithea``.
+  If necessary, create the top directory for the virtualenv (like
+  ``/srv/kallithea/venv``) as root and assign ownership to the user.
+
+  Make a parent folder for the virtualenv (and perhaps also Kallithea
+  configuration and data files) such as ``/srv/kallithea``. Create the
+  directory as root if necessary and grant ownership to the ``kallithea`` user.
+
+- Create a new virtual environment, for example in ``/srv/kallithea/venv``,
+  specifying the right Python binary::
 
     python3 -m venv /srv/kallithea/venv
 
 - Activate the virtualenv in your current shell session and make sure the
-  basic requirements are up-to-date by running::
+  basic requirements are up-to-date by running the following commands in your
+  bash shell::
 
     . /srv/kallithea/venv/bin/activate
     pip install --upgrade pip setuptools
 
-.. note:: You can't use UNIX ``sudo`` to source the ``virtualenv`` script; it
-   will "activate" a shell that terminates immediately. It is also perfectly
-   acceptable (and desirable) to create a virtualenv as a normal user.
+.. note:: You can't use UNIX ``sudo`` to source the ``activate`` script; it
+   will "activate" a shell that terminates immediately.
 
-- Make a folder for Kallithea data files, and configuration somewhere on the
-  filesystem. For example::
-
-    mkdir /srv/kallithea
-
-- Go into the created directory and run this command to install Kallithea::
+- Install Kallithea in the activated virtualenv::
 
     pip install --upgrade kallithea
 
@@ -105,31 +115,30 b' An additional benefit of virtualenv is t'
    This might require installation of development packages using your
    distribution's package manager.
 
-  Alternatively, download a .tar.gz from http://pypi.python.org/pypi/Kallithea,
-  extract it and install from source by running::
+   Alternatively, download a .tar.gz from http://pypi.python.org/pypi/Kallithea,
+   extract it and install from source by running::
 
-    pip install --upgrade .
+     pip install --upgrade .
 
 - This will install Kallithea together with all other required
   Python libraries into the activated virtualenv.
 
-You can now proceed to :ref:`setup`.
+You can now proceed to :ref:`prepare-front-end-files`.
 
-.. _installation-without-virtualenv:
+.. _prepare-front-end-files:
 
 
-Installing a released version without virtualenv
-------------------------------------------------
-
-For installation without virtualenv, 'just' use::
-
-    pip install kallithea
+Prepare front-end files
+-----------------------
 
-Note that this method requires root privileges and will install packages
-globally without using the system's package manager.
+Finally, the front-end files with CSS and JavaScript must be prepared. This
+depends on having some commands available in the shell search path: ``npm``
+version 6 or later, and ``node.js`` (version 12 or later) available as
+``node``. The installation method for these dependencies varies between
+operating systems and distributions.
 
-To install as a regular user in ``~/.local``, you can use::
+Prepare the front-end by running::
 
-    pip install --user kallithea
+    kallithea-cli front-end-build
 
 You can now proceed to :ref:`setup`.

docs/overview.rst

@@ -20,23 +20,27 b' 1. **Prepare environment and external de'
 2. **Install Kallithea software.**
     This makes the ``kallithea-cli`` command line tool available.
 
-3. **Create low level configuration file.**
+3. **Prepare front-end files**
+    Some front-end files must be fetched or created using ``npm`` and ``node``
+    tooling so they can be served to the client as static files.
+
+4. **Create low level configuration file.**
     Use ``kallithea-cli config-create`` to create a ``.ini`` file with database
     connection info, mail server information, configuration for the specified
     web server, etc.
 
-4. **Populate the database.**
+5. **Populate the database.**
     Use ``kallithea-cli db-create`` with the ``.ini`` file to create the
     database schema and insert the most basic information: the location of the
     repository store and an initial local admin user.
 
-5. **Configure the web server.**
+6. **Configure the web server.**
     The web server must invoke the WSGI entrypoint for the Kallithea software
     using the ``.ini`` file (and thus the database). This makes the web
     application available so the local admin user can log in and tweak the
     configuration further.
 
-6. **Configure users.**
+7. **Configure users.**
     The initial admin user can create additional local users, or configure how
     users can be created and authenticated from other user directories.
 
@@ -44,6 +48,45 b' See the subsequent sections, the separat'
 :ref:`setup` for details on these steps.
 
 
+File system location
+--------------------
+
+Kallithea can be installed in many different ways. The main parts are:
+
+- A location for the Kallithea software and its dependencies. This includes
+  the Python code, template files, and front-end code. After installation, this
+  will be read-only (except when upgrading).
+
+- A location for the ``.ini`` configuration file that tells the Kallithea
+  instance which database to use (and thus also the repository location).
+  After installation, this will be read-only (except when upgrading).
+
+- A location for various data files and caches for the Kallithea instance. This
+  is by default in a ``data`` directory next to the ``.ini`` file. This will
+  have to be writable by the running Kallithea service.
+
+- A database. The ``.ini`` file specifies which database to use. The database
+  will be a separate service and live elsewhere in the filesystem if using
+  PostgreSQL or MariaDB/MySQL. If using SQLite, it will by default live next to
+  the ``.ini`` file, as ``kallithea.db``.
+
+- A location for the repositories that are hosted by this Kallithea instance.
+  This will have to be writable by the running Kallithea service. The path to
+  this location will be configured in the database.
+
+For production setups, one recommendation is to use ``/srv/kallithea`` for the
+``.ini`` and ``data``, place the virtualenv in ``venv``, and use a Kallithea
+clone in ``kallithea``. Create a ``kallithea`` user, let it own
+``/srv/kallithea``, and run as that user when installing.
+
+For simple setups, it is fine to just use something like a ``kallithea`` user
+with home in ``/home/kallithea`` and place everything there.
+
+For experiments, it might be convenient to run everything as yourself and work
+inside a clone of Kallithea, with the ``.ini`` and SQLite database in the root
+of the clone, and a virtualenv in ``venv``.
+
+
 Python environment
 ------------------
 
@@ -177,7 +220,7 b' There are several web server options:'
   to get a configuration starting point for your choice of web server.
 
   (Gearbox will do like ``paste`` and use the WSGI application entry point
-  ``kallithea.config.middleware:make_app`` as specified in ``setup.py``.)
+  ``kallithea.config.application:make_app`` as specified in ``setup.py``.)
 
 - `Apache httpd`_ can serve WSGI applications directly using mod_wsgi_ and a
   simple Python file with the necessary configuration. This is a good option if
@@ -216,13 +259,13 b' continuous hammering from the internet.'
 .. _Python: http://www.python.org/
 .. _Gunicorn: http://gunicorn.org/
 .. _Gevent: http://www.gevent.org/
-.. _Waitress: http://waitress.readthedocs.org/en/latest/
-.. _Gearbox: http://turbogears.readthedocs.io/en/latest/turbogears/gearbox.html
+.. _Waitress: https://docs.pylonsproject.org/projects/waitress/
+.. _Gearbox: https://turbogears.readthedocs.io/en/latest/turbogears/gearbox.html
 .. _PyPI: https://pypi.python.org/pypi
 .. _Apache httpd: http://httpd.apache.org/
-.. _mod_wsgi: https://code.google.com/p/modwsgi/
+.. _mod_wsgi: https://modwsgi.readthedocs.io/
 .. _isapi-wsgi: https://github.com/hexdump42/isapi-wsgi
-.. _uWSGI: https://uwsgi-docs.readthedocs.org/en/latest/
+.. _uWSGI: https://uwsgi-docs.readthedocs.io/
 .. _nginx: http://nginx.org/en/
 .. _iis: http://en.wikipedia.org/wiki/Internet_Information_Services
 .. _pip: http://en.wikipedia.org/wiki/Pip_%28package_manager%29

docs/setup.rst

@@ -5,35 +5,72 b' Setup'
 =====
 
 
-Setting up Kallithea
---------------------
+Setting up a Kallithea instance
+-------------------------------
+
+Some further details to the steps mentioned in the overview.
 
-First, you will need to create a Kallithea configuration file. Run the
-following command to do so::
+Create low level configuration file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+First, you will need to create a Kallithea configuration file. The
+configuration file is a ``.ini`` file that contains various low level settings
+for Kallithea, e.g. configuration of how to use database, web server, email,
+and logging.
 
-    kallithea-cli config-create my.ini
+Change to the desired directory (such as ``/srv/kallithea``) as the right user
+and run the following command to create the file ``my.ini`` in the current
+directory::
+
+    kallithea-cli config-create my.ini http_server=waitress
 
-This will create the file ``my.ini`` in the current directory. This
-configuration file contains the various settings for Kallithea, e.g.
-proxy port, email settings, usage of static files, cache, Celery
-settings, and logging. Extra settings can be specified like::
+To get a good starting point for your configuration, specify the http server
+you intend to use. It can be ``waitress``, ``gearbox``, ``gevent``,
+``gunicorn``, or ``uwsgi``. (Apache ``mod_wsgi`` will not use this
+configuration file, and it is fine to keep the default http_server configuration
+unused. ``mod_wsgi`` is configured using ``httpd.conf`` directives and a WSGI
+wrapper script.)
+
+Extra custom settings can be specified like::
 
     kallithea-cli config-create my.ini host=8.8.8.8 "[handler_console]" formatter=color_formatter
 
-Next, you need to create the databases used by Kallithea. It is recommended to
-use PostgreSQL or SQLite (default). If you choose a database other than the
-default, ensure you properly adjust the database URL in your ``my.ini``
-configuration file to use this other database. Kallithea currently supports
-PostgreSQL, SQLite and MariaDB/MySQL databases. Create the database by running
-the following command::
+Populate the database
+^^^^^^^^^^^^^^^^^^^^^
+
+Next, you need to create the databases used by Kallithea. Kallithea currently
+supports PostgreSQL, SQLite and MariaDB/MySQL databases. It is recommended to
+start out using SQLite (the default) and move to PostgreSQL if it becomes a
+bottleneck or to get a "proper" database. MariaDB/MySQL is also supported.
+
+For PostgreSQL, run ``pip install psycopg2`` to get the database driver. Make
+sure the PostgreSQL server is initialized and running. Make sure you have a
+database user with password authentication with permissions to create databases
+- for example by running::
+
+    sudo -u postgres createuser 'kallithea' --pwprompt --createdb
+
+For MariaDB/MySQL, run ``pip install mysqlclient`` to get the ``MySQLdb``
+database driver. Make sure the database server is initialized and running. Make
+sure you have a database user with password authentication with permissions to
+create the database - for example by running::
+
+    echo 'CREATE USER "kallithea"@"localhost" IDENTIFIED BY "password"' | sudo -u mysql mysql
+    echo 'GRANT ALL PRIVILEGES ON `kallithea`.* TO "kallithea"@"localhost"' | sudo -u mysql mysql
+
+Check and adjust ``sqlalchemy.url`` in your ``my.ini`` configuration file to use
+this database.
+
+Create the database, tables, and initial content by running the following
+command::
 
     kallithea-cli db-create -c my.ini
 
-This will prompt you for a "root" path. This "root" path is the location where
-Kallithea will store all of its repositories on the current machine. After
-entering this "root" path ``db-create`` will also prompt you for a username
-and password for the initial admin account which ``db-create`` sets
-up for you.
+This will first prompt you for a "root" path. This "root" path is the location
+where Kallithea will store all of its repositories on the current machine. This
+location must be writable for the running Kallithea application. Next,
+``db-create`` will prompt you for a username and password for the initial admin
+account it sets up for you.
 
 The ``db-create`` values can also be given on the command line.
 Example::
@@ -48,19 +85,20 b' repositories Kallithea will add all of t'
 location to its database.  (Note: make sure you specify the correct
 path to the root).
 
-.. note:: the given path for Mercurial_ repositories **must** be write
-          accessible for the application. It's very important since
-          the Kallithea web interface will work without write access,
-          but when trying to do a push it will fail with permission
-          denied errors unless it has write access.
+.. note:: It is also possible to use an existing database. For example,
+          when using PostgreSQL without granting general createdb privileges to
+          the PostgreSQL kallithea user, set ``sqlalchemy.url =
+          postgresql://kallithea:password@localhost/kallithea`` and create the
+          database like::
 
-Finally, the front-end files must be prepared. This requires ``npm`` version 6
-or later, which needs ``node.js`` (version 12 or later). Prepare the front-end
-by running::
+              sudo -u postgres createdb 'kallithea' --owner 'kallithea'
+              kallithea-cli db-create -c my.ini --reuse
 
-    kallithea-cli front-end-build
+Running
+^^^^^^^
 
-You are now ready to use Kallithea. To run it simply execute::
+You are now ready to use Kallithea. To run it using a gearbox web server,
+simply execute::
 
     gearbox serve -c my.ini
 
@@ -186,7 +224,7 b' Setting up Whoosh full text search'
 
 Kallithea provides full text search of repositories using `Whoosh`__.
 
-.. __: https://whoosh.readthedocs.io/en/latest/
+.. __: https://whoosh.readthedocs.io/
 
 For an incremental index build, run::
 
@@ -300,15 +338,21 b' the supported syntax in ``issue_pat``, `'
 Hook management
 ---------------
 
-Hooks can be managed in similar way to that used in ``.hgrc`` files.
+Custom Mercurial hooks can be managed in a similar way to that used in ``.hgrc`` files.
 To manage hooks, choose *Admin > Settings > Hooks*.
 
-The built-in hooks cannot be modified, though they can be enabled or disabled in the *VCS* section.
-
 To add another custom hook simply fill in the first textbox with
 ``<name>.<hook_type>`` and the second with the hook path. Example hooks
 can be found in ``kallithea.lib.hooks``.
 
+Kallithea will also use some hooks internally. They cannot be modified, but
+some of them can be enabled or disabled in the *VCS* section.
+
+Kallithea does not actively support custom Git hooks, but hooks can be installed
+manually in the file system. Kallithea will install and use the
+``post-receive`` Git hook internally, but it will then invoke
+``post-receive-custom`` if present.
+
 
 Changing default encoding
 -------------------------
@@ -362,6 +406,38 b' for more info.'
    user that Kallithea runs.
 
 
+Proxy setups
+------------
+
+When Kallithea is processing HTTP requests from a user, it will see and use
+some of the basic properties of the connection, both at the TCP/IP level and at
+the HTTP level. The WSGI server will provide this information to Kallithea in
+the "environment".
+
+In some setups, a proxy server will take requests from users and forward
+them to the actual Kallithea server. The proxy server will thus be the
+immediate client of the Kallithea WSGI server, and Kallithea will basically see
+it as such. To make sure Kallithea sees the request as it arrived from the
+client to the proxy server, the proxy server must be configured to
+somehow pass the original information on to Kallithea, and Kallithea must be
+configured to pick that information up and trust it.
+
+Kallithea will by default rely on its WSGI server to provide the IP of the
+client in the WSGI environment as ``REMOTE_ADDR``, but it can be configured to
+get it from an HTTP header that has been set by the proxy server. For
+example, if the proxy server puts the client IP in the ``X-Forwarded-For``
+HTTP header, set::
+
+    remote_addr_variable = HTTP_X_FORWARDED_FOR
+
+Kallithea will by default rely on finding the protocol (``http`` or ``https``)
+in the WSGI environment as ``wsgi.url_scheme``. If the proxy server puts
+the protocol of the client request in the ``X-Forwarded-Proto`` HTTP header,
+Kallithea can be configured to trust that header by setting::
+
+    url_scheme_variable = HTTP_X_FORWARDED_PROTO
+
+
 HTTPS support
 -------------
 
@@ -370,10 +446,9 b' Kallithea will by default generate URLs '
 Alternatively, you can use some special configuration settings to control
 directly which scheme/protocol Kallithea will use when generating URLs:
 
-- With ``https_fixup = true``, the scheme will be taken from the
-  ``X-Url-Scheme``, ``X-Forwarded-Scheme`` or ``X-Forwarded-Proto`` HTTP header
-  (default ``http``).
-- With ``force_https = true`` the default will be ``https``.
+- With ``url_scheme_variable`` set, the scheme will be taken from that HTTP
+  header.
+- With ``force_https = true``, the scheme will be seen as ``https``.
 - With ``use_htsts = true``, Kallithea will set ``Strict-Transport-Security`` when using https.
 
 .. _nginx_virtual_host:
@@ -556,43 +631,19 b" that, you'll need to:"
 
     WSGIRestrictEmbedded On
 
-- Create a WSGI dispatch script, like the one below. Make sure you
-  check that the paths correctly point to where you installed Kallithea
-  and its Python Virtual Environment.
+- Create a WSGI dispatch script, like the one below. The ``WSGIDaemonProcess``
+  ``python-home`` directive will make sure it uses the right Python Virtual
+  Environment and that paste thus can pick up the right Kallithea
+  application.
 
   .. code-block:: python
 
-      import os
-      os.environ['PYTHON_EGG_CACHE'] = '/srv/kallithea/.egg-cache'
-
-      # sometimes it's needed to set the current dir
-      os.chdir('/srv/kallithea/')
-
-      import site
-      site.addsitedir("/srv/kallithea/venv/lib/python3.7/site-packages")
-
       ini = '/srv/kallithea/my.ini'
       from logging.config import fileConfig
       fileConfig(ini, {'__file__': ini, 'here': '/srv/kallithea'})
       from paste.deploy import loadapp
       application = loadapp('config:' + ini)
 
-  Or using proper virtualenv activation:
-
-  .. code-block:: python
-
-      activate_this = '/srv/kallithea/venv/bin/activate_this.py'
-      execfile(activate_this, dict(__file__=activate_this))
-
-      import os
-      os.environ['HOME'] = '/srv/kallithea'
-
-      ini = '/srv/kallithea/kallithea.ini'
-      from logging.config import fileConfig
-      fileConfig(ini, {'__file__': ini, 'here': '/srv/kallithea'})
-      from paste.deploy import loadapp
-      application = loadapp('config:' + ini)
-
 - Add the necessary ``WSGI*`` directives to the Apache Virtual Host configuration
   file, like in the example below. Notice that the WSGI dispatch script created
   above is referred to with the ``WSGIScriptAlias`` directive.
@@ -617,15 +668,6 b" that, you'll need to:"
       WSGIScriptAlias / /srv/kallithea/dispatch.wsgi
       WSGIPassAuthorization On
 
-  Or if using a dispatcher WSGI script with proper virtualenv activation:
-
-  .. code-block:: apache
-
-      WSGIDaemonProcess kallithea processes=5 threads=1 maximum-requests=100 lang=en_US.utf8
-      WSGIProcessGroup kallithea
-      WSGIScriptAlias / /srv/kallithea/dispatch.wsgi
-      WSGIPassAuthorization On
-
 
 Other configuration files
 -------------------------

docs/upgrade.rst

@@ -39,8 +39,8 b' Back up your configuration'
 
 Make a copy of your Kallithea configuration (``.ini``) file.
 
-If you are using :ref:`rcextensions <customization>`, you should also
-make a copy of the entire ``rcextensions`` directory.
+If you are using custom :ref:`extensions <customization>`, you should also
+make a copy of the ``extensions.py`` file.
 
 Back up your database
 ^^^^^^^^^^^^^^^^^^^^^
@@ -225,14 +225,21 b' clear out your log file so that new erro'
     upgrade.
 
 
-10. Update Git repository hooks
--------------------------------
+10. Reinstall internal Git repository hooks
+-------------------------------------------
 
 It is possible that an upgrade involves changes to the Git hooks installed by
 Kallithea. As these hooks are created inside the repositories on the server
 filesystem, they are not updated automatically when upgrading Kallithea itself.
 
-To update the hooks of your Git repositories:
+To update the hooks of your Git repositories, run::
+
+    kallithea-cli repo-scan -c my.ini --install-git-hooks
+
+Watch out for warnings like ``skipping overwriting hook file X``, then fix it
+and rerun, or consider using ``--overwrite-git-hooks`` instead.
+
+Or:
 
 * Go to *Admin > Settings > Remap and Rescan*
 * Select the checkbox *Install Git hooks*

docs/usage/customization.rst

@@ -39,13 +39,14 b' running::'
 .. _less: http://lesscss.org/
 
 
-Behavioral customization: rcextensions
---------------------------------------
+Behavioral customization: Kallithea extensions
+----------------------------------------------
 
-Some behavioral customization can be done in Python using ``rcextensions``, a
-custom Python package that can extend Kallithea functionality.
+Some behavioral customization can be done in Python using Kallithea
+``extensions``, a custom Python file you can create to extend Kallithea
+functionality.
 
-With ``rcextensions`` it's possible to add additional mappings for Whoosh
+With ``extensions`` it's possible to add additional mappings for Whoosh
 indexing and statistics, to add additional code into the push/pull/create/delete
 repository hooks (for example to send signals to build bots such as Jenkins) and
 even to monkey-patch certain parts of the Kallithea source code (for example
@@ -55,9 +56,14 b' To generate a skeleton extensions packag'
 
     kallithea-cli extensions-create -c my.ini
 
-This will create an ``rcextensions`` package next to the specified ``ini`` file.
-See the ``__init__.py`` file inside the generated ``rcextensions`` package
-for more details.
+This will create an ``extensions.py`` file next to the specified ``ini`` file.
+You can find more details inside this file.
+
+For compatibility with previous releases of Kallithea, a directory named
+``rcextensions`` with a file ``__init__.py`` inside of it can also be used. If
+both an ``extensions.py`` file and an ``rcextensions`` directory are found, only
+``extensions.py`` will be loaded. Note that the name ``rcextensions`` is
+deprecated and support for it will be removed in a future release.
 
 
 Behavioral customization: code changes

docs/usage/email.rst

@@ -89,8 +89,8 b' a name and an address in the following f'
 References
 ----------
 
-- `Error Middleware (Pylons documentation) <http://pylons-webframework.readthedocs.org/en/latest/debugging.html#error-middleware>`_
-- `ErrorHandler (Pylons modules documentation) <http://pylons-webframework.readthedocs.org/en/latest/modules/middleware.html#pylons.middleware.ErrorHandler>`_
+- `Error Middleware (Pylons documentation) <https://pylons-webframework.readthedocs.io/en/latest/debugging.html#error-middleware>`_
+- `ErrorHandler (Pylons modules documentation) <https://pylons-webframework.readthedocs.io/en/latest/modules/middleware.html#pylons.middleware.ErrorHandler>`_
 
 
 .. _backlash: https://github.com/TurboGears/backlash

docs/usage/general.rst

@@ -118,22 +118,15 b' Trending source files'
 
 Trending source files are calculated based on a predefined dictionary of known
 types and extensions. If an extension is missing or you would like to scan
-custom files, it is possible to extend the ``LANGUAGES_EXTENSIONS_MAP``
-dictionary located in ``kallithea/config/conf.py`` with new types.
+custom files, it is possible to add additional file extensions with
+``EXTRA_MAPPINGS`` in your custom Kallithea extensions.py file. See
+:ref:`customization`.
 
 
 Cloning remote repositories
 ---------------------------
 
 Kallithea has the ability to clone repositories from given remote locations.
-Currently it supports the following options:
-
-- hg  -> hg clone
-- svn -> hg clone
-- git -> git clone
-
-.. note:: svn -> hg cloning requires the ``hgsubversion`` library to be
-   installed.
 
 If you need to clone repositories that are protected via basic authentication,
 you can pass the credentials in the URL, e.g.

docs/usage/performance.rst

@@ -48,42 +48,37 b' database platform.'
 Horizontal scaling
 ------------------
 
-Scaling horizontally means running several Kallithea instances and let them
-share the load. That can give huge performance benefits when dealing with large
-amounts of traffic (many users, CI servers, etc.). Kallithea can be scaled
-horizontally on one (recommended) or multiple machines.
+Scaling horizontally means running several Kallithea instances (also known as
+worker processes) and let them share the load. That is essential to serve other
+users while processing a long-running request from a user. Usually, the
+bottleneck on a Kallithea server is not CPU but I/O speed - especially network
+speed. It is thus a good idea to run multiple worker processes on one server.
 
-It is generally possible to run WSGI applications multithreaded, so that
-several HTTP requests are served from the same Python process at once. That can
-in principle give better utilization of internal caches and less process
-overhead.
+.. note::
 
-One danger of running multithreaded is that program execution becomes much more
-complex; programs must be written to consider all combinations of events and
-problems might depend on timing and be impossible to reproduce.
+    Kallithea and the embedded Mercurial backend are not thread-safe. Each
+    worker process must thus be single-threaded.
 
-Kallithea can't promise to be thread-safe, just like the embedded Mercurial
-backend doesn't make any strong promises when used as Kallithea uses it.
-Instead, we recommend scaling by using multiple server processes.
+Web servers can usually launch multiple worker processes - for example ``mod_wsgi`` with the
+``WSGIDaemonProcess`` ``processes`` parameter or ``uWSGI`` or ``gunicorn`` with
+their ``workers`` setting.
 
-Web servers with multiple worker processes (such as ``mod_wsgi`` with the
-``WSGIDaemonProcess`` ``processes`` parameter) will work out of the box.
-
+Kallithea can also be scaled horizontally across multiple machines.
 In order to scale horizontally on multiple machines, you need to do the
 following:
 
-    - Each instance's ``data`` storage needs to be configured to be stored on a
-      shared disk storage, preferably together with repositories. This ``data``
-      dir contains template caches, sessions, whoosh index and is used for
-      task locking (so it is safe across multiple instances). Set the
-      ``cache_dir``, ``index_dir``, ``beaker.cache.data_dir``, ``beaker.cache.lock_dir``
-      variables in each .ini file to a shared location across Kallithea instances
-    - If using several Celery instances,
-      the message broker should be common to all of them (e.g.,  one
-      shared RabbitMQ server)
-    - Load balance using round robin or IP hash, recommended is writing LB rules
-      that will separate regular user traffic from automated processes like CI
-      servers or build bots.
+- Each instance's ``data`` storage needs to be configured to be stored on a
+  shared disk storage, preferably together with repositories. This ``data``
+  dir contains template caches, sessions, whoosh index and is used for
+  task locking (so it is safe across multiple instances). Set the
+  ``cache_dir``, ``index_dir``, ``beaker.cache.data_dir``, ``beaker.cache.lock_dir``
+  variables in each .ini file to a shared location across Kallithea instances
+- If using several Celery instances,
+  the message broker should be common to all of them (e.g.,  one
+  shared RabbitMQ server)
+- Load balance using round robin or IP hash, recommended is writing LB rules
+  that will separate regular user traffic from automated processes like CI
+  servers or build bots.
 
 
 Serve static files directly from the web server
@@ -125,3 +120,6 b' response. See the documentation for your'
 
 
 .. _SQLAlchemyGrate: https://github.com/shazow/sqlalchemygrate
+.. _mod_wsgi: https://modwsgi.readthedocs.io/
+.. _uWSGI: https://uwsgi-docs.readthedocs.io/
+.. _gunicorn: http://pypi.python.org/pypi/gunicorn

docs/usage/troubleshooting.rst

@@ -43,12 +43,19 b' Troubleshooting'
 |
 
 :Q: **How can I use hooks in Kallithea?**
-:A: It's easy if they are Python hooks: just use advanced link in
-    hooks section in Admin panel, that works only for Mercurial. If
-    you want to use Git hooks, just install th proper one in the repository,
-    e.g., create a file `/gitrepo/hooks/pre-receive`. You can also use
-    Kallithea-extensions to connect to callback hooks, for both Git
-    and Mercurial.
+:A: If using Mercurial, use *Admin > Settings > Hooks* to install
+    global hooks. Inside the hooks, you can use the current working directory to
+    control different behaviour for different repositories.
+
+    If using Git, install the hooks manually in each repository, for example by
+    creating a file ``gitrepo/hooks/pre-receive``.
+    Note that Kallithea uses the ``post-receive`` hook internally.
+    Kallithea will not work properly if another post-receive hook is installed instead.
+    You might also accidentally overwrite your own post-receive hook with the Kallithea hook.
+    Instead, put your post-receive hook in ``post-receive-custom``, and the Kallithea hook will invoke it.
+
+    You can also use Kallithea-extensions to connect to callback hooks,
+    for both Git and Mercurial.
 
 |
 

init.d/kallithea-daemon-debian

@@ -37,7 +37,7 b' DAEMON_OPTS="serve --daemon \\'
 
 start() {
   echo "Starting $APP_NAME"
-  PYTHON_EGG_CACHE="/tmp" start-stop-daemon -d $APP_PATH \
+  start-stop-daemon -d $APP_PATH \
       --start --quiet \
       --pidfile $PID_PATH \
       --user $RUN_AS \

init.d/kallithea-daemon-gentoo

@@ -33,7 +33,7 b' depend() {'
 
 start() {
     ebegin "Starting $APP_NAME"
-    start-stop-daemon -d $APP_PATH -e PYTHON_EGG_CACHE="/tmp" \
+    start-stop-daemon -d $APP_PATH \
         --start --quiet \
         --pidfile $PID_PATH \
         --user $RUN_AS \

init.d/kallithea-daemon-redhat

@@ -63,7 +63,7 b' ensure_pid_dir () {'
 
 start_kallithea () {
     ensure_pid_dir
-    PYTHON_EGG_CACHE="/tmp" daemon --pidfile $PID_PATH \
+    daemon --pidfile $PID_PATH \
         --user $RUN_AS "$DAEMON $DAEMON_OPTS"
     RETVAL=$?
     [ $RETVAL -eq 0 ] && touch $LOCK_FILE

kallithea/__init__.py

@@ -30,20 +30,26 b' Original author and date, and relevant c'
 import platform
 import sys
 
+import celery
+
 
 if sys.version_info < (3, 6):
     raise Exception('Kallithea requires python 3.6 or later')
 
-VERSION = (0, 6, 3)
+VERSION = (0, 6, 99)
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
 }
 
-CELERY_APP = None  # set to Celery app instance if using Celery
-CELERY_EAGER = False
+CELERY_APP = celery.Celery()  # needed at import time but is lazy and can be configured later
 
-CONFIG = {}
+DEFAULT_USER_ID: int  # set by setup_configuration
+CONFIG = {}  # set to tg.config when TG app is initialized and calls app_cfg
+
+# URL prefix for non repository related links - must start with `/`
+ADMIN_PREFIX = '/_admin'
+URL_SEP = '/'
 
 # Linked module for extensions
 EXTENSIONS = {}

kallithea/alembic/env.py

@@ -21,7 +21,7 b' from logging.config import fileConfig'
 from alembic import context
 from sqlalchemy import engine_from_config, pool
 
-from kallithea.model import db
+from kallithea.model import meta
 
 
 # The alembic.config.Config object, which wraps the current .ini file.
@@ -93,7 +93,7 b' def run_migrations_online():'
 
             # Support autogeneration of migration scripts based on "diff" between
             # current database schema and kallithea.model.db schema.
-            target_metadata=db.Base.metadata,
+            target_metadata=meta.Base.metadata,
             include_object=include_in_autogeneration,
             render_as_batch=True, # batch mode is needed for SQLite support
         )

kallithea/alembic/versions/a020f7044fd6_rename_hooks.py

@@ -29,7 +29,7 b' depends_on = None'
 from alembic import op
 from sqlalchemy import MetaData, Table
 
-from kallithea.model.db import Ui
+from kallithea.model import db
 
 
 meta = MetaData()
@@ -37,7 +37,7 b' meta = MetaData()'
 
 def upgrade():
     meta.bind = op.get_bind()
-    ui = Table(Ui.__tablename__, meta, autoload=True)
+    ui = Table(db.Ui.__tablename__, meta, autoload=True)
 
     ui.update(values={
         'ui_key': 'prechangegroup.push_lock_handling',
@@ -51,7 +51,7 b' def upgrade():'
 
 def downgrade():
     meta.bind = op.get_bind()
-    ui = Table(Ui.__tablename__, meta, autoload=True)
+    ui = Table(db.Ui.__tablename__, meta, autoload=True)
 
     ui.update(values={
         'ui_key': 'prechangegroup.pre_push',

kallithea/alembic/versions/ad357ccd9521_drop_locking.py

@@ -30,7 +30,7 b' import sqlalchemy as sa'
 from alembic import op
 from sqlalchemy import MetaData, Table
 
-from kallithea.model.db import Ui
+from kallithea.model import db
 
 
 meta = MetaData()
@@ -45,7 +45,7 b' def upgrade():'
         batch_op.drop_column('enable_locking')
 
     meta.bind = op.get_bind()
-    ui = Table(Ui.__tablename__, meta, autoload=True)
+    ui = Table(db.Ui.__tablename__, meta, autoload=True)
     ui.delete().where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()
     ui.delete().where(ui.c.ui_key == 'preoutgoing.pull_lock_handling').execute()
 

kallithea/bin/kallithea_cli_base.py

@@ -23,7 +23,7 b' import click'
 import paste.deploy
 
 import kallithea
-import kallithea.config.middleware
+import kallithea.config.application
 
 
 # kallithea_cli is usually invoked through the 'kallithea-cli' wrapper script
@@ -53,10 +53,10 b' def read_config(ini_file_name, strip_sec'
 def cli():
     """Various commands to manage a Kallithea instance."""
 
-def register_command(config_file=False, config_file_initialize_app=False, hidden=False):
+def register_command(needs_config_file=False, config_file_initialize_app=False, hidden=False):
     """Register a kallithea-cli subcommand.
 
-    If one of the config_file flags are true, a config file must be specified
+    If one of the needs_config_file flags are true, a config file must be specified
     with -c and it is read and logging is configured. The configuration is
     available in the kallithea.CONFIG dict.
 
@@ -64,21 +64,23 b' def register_command(config_file=False, '
     (including tg.config), and database access will also be fully initialized.
     """
     cli_command = cli.command(hidden=hidden)
-    if config_file or config_file_initialize_app:
+    if needs_config_file or config_file_initialize_app:
         def annotator(annotated):
             @click.option('--config_file', '-c', help="Path to .ini file with app configuration.",
                 type=click.Path(dir_okay=False, exists=True, readable=True), required=True)
             @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options
             def runtime_wrapper(config_file, *args, **kwargs):
                 path_to_ini_file = os.path.realpath(config_file)
-                kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)
+                config = paste.deploy.appconfig('config:' + path_to_ini_file)
                 cp = configparser.ConfigParser(strict=False)
                 cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))
                 logging.config.fileConfig(cp,
                     {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})
+                if needs_config_file:
+                    annotated(*args, config=config, **kwargs)
                 if config_file_initialize_app:
-                    kallithea.config.middleware.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
-                return annotated(*args, **kwargs)
+                    kallithea.config.application.make_app(config.global_conf, **config.local_conf)
+                    annotated(*args, **kwargs)
             return cli_command(runtime_wrapper)
         return annotator
     return cli_command

kallithea/bin/kallithea_cli_celery.py

@@ -12,16 +12,18 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import celery.bin.worker
 import click
+from celery.bin.celery import celery as celery_command
 
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
+from kallithea.lib import celery_app
+from kallithea.lib.utils2 import asbool
 
 
-@cli_base.register_command(config_file_initialize_app=True)
+@cli_base.register_command(needs_config_file=True)
 @click.argument('celery_args', nargs=-1)
-def celery_run(celery_args):
+def celery_run(celery_args, config):
     """Start Celery worker(s) for asynchronous tasks.
 
     This commands starts the Celery daemon which will spawn workers to handle
@@ -32,9 +34,20 b' def celery_run(celery_args):'
     by this CLI command.
     """
 
-    if not kallithea.CELERY_APP:
+    if not asbool(config.get('use_celery')):
         raise Exception('Please set use_celery = true in .ini config '
                         'file before running this command')
 
-    cmd = celery.bin.worker.worker(kallithea.CELERY_APP)
-    return cmd.run_from_argv(None, command='celery-run -c CONFIG_FILE --', argv=list(celery_args))
+    kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))
+
+    kallithea.CELERY_APP.loader.on_worker_process_init = lambda: kallithea.config.application.make_app(config.global_conf, **config.local_conf)
+
+    args = list(celery_args)
+    # args[0] is generally ignored when prog_name is specified, but -h *needs* it to be 'worker' ... but will also suggest that users specify 'worker' explicitly
+    if not args or args[0] != 'worker':
+        args.insert(0, 'worker')
+
+    # inline kallithea.CELERY_APP.start in order to allow specifying prog_name
+    assert celery_command.params[0].name == 'app'
+    celery_command.params[0].default = kallithea.CELERY_APP
+    celery_command.main(args=args, prog_name='kallithea-cli celery-run -c CONFIG_FILE --')

kallithea/bin/kallithea_cli_config.py

@@ -21,7 +21,7 b' import click'
 import mako.exceptions
 
 import kallithea.bin.kallithea_cli_base as cli_base
-import kallithea.lib.locale
+import kallithea.lib.locales
 from kallithea.lib import inifile
 
 
@@ -66,7 +66,7 b' def config_create(config_file, key_value'
         'git_hook_interpreter': sys.executable,
         'user_home_path': os.path.expanduser('~'),
         'kallithea_cli_path': cli_base.kallithea_cli_path,
-        'ssh_locale': kallithea.lib.locale.get_current_locale(),
+        'ssh_locale': kallithea.lib.locales.get_current_locale(),
     }
     ini_settings = defaultdict(dict)
 

kallithea/bin/kallithea_cli_db.py

@@ -15,11 +15,15 b' import click'
 
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
+import kallithea.lib.utils
+import kallithea.model.scm
 from kallithea.lib.db_manage import DbManage
-from kallithea.model.meta import Session
+from kallithea.model import meta
 
 
-@cli_base.register_command(config_file=True)
+@cli_base.register_command(needs_config_file=True, config_file_initialize_app=True)
[e-mail]('--reuse/--no-reuse', default=False,
+        help='Reuse and clean existing database instead of dropping and creating (default: no reuse)')
 @click.option('--user', help='Username of administrator account.')
 @click.option('--password', help='Password for administrator account.')
 @click.option('--email', help='Email address of administrator account.')
@@ -28,7 +32,7 b' from kallithea.model.meta import Session'
 @click.option('--force-no', is_flag=True, help='Answer no to every question.')
 @click.option('--public-access/--no-public-access', default=True,
         help='Enable/disable public access on this installation (default: enable)')
-def db_create(user, password, email, repos, force_yes, force_no, public_access):
+def db_create(user, password, email, repos, force_yes, force_no, public_access, reuse, config=None):
     """Initialize the database.
 
     Create all required tables in the database specified in the configuration
@@ -37,44 +41,43 b' def db_create(user, password, email, rep'
 
     You can pass the answers to all questions as options to this command.
     """
-    dbconf = kallithea.CONFIG['sqlalchemy.url']
+    if config is not None:  # first called with config, before app initialization
+        dbconf = config['sqlalchemy.url']
 
-    # force_ask should be True (yes), False (no), or None (ask)
-    if force_yes:
-        force_ask = True
-    elif force_no:
-        force_ask = False
-    else:
-        force_ask = None
+        # force_ask should be True (yes), False (no), or None (ask)
+        if force_yes:
+            force_ask = True
+        elif force_no:
+            force_ask = False
+        else:
+            force_ask = None
 
-    cli_args = dict(
-            username=user,
-            password=password,
-            email=email,
-            repos_location=repos,
-            force_ask=force_ask,
-            public_access=public_access,
-    )
-    dbmanage = DbManage(dbconf=dbconf, root=kallithea.CONFIG['here'],
-                        tests=False, cli_args=cli_args)
-    dbmanage.create_tables(override=True)
-    repo_root_path = dbmanage.prompt_repo_root_path(None)
-    dbmanage.create_settings(repo_root_path)
-    dbmanage.create_default_user()
-    dbmanage.admin_prompt()
-    dbmanage.create_permissions()
-    dbmanage.populate_default_permissions()
-    Session().commit()
+        cli_args = dict(
+                username=user,
+                password=password,
+                email=email,
+                repos_location=repos,
+                force_ask=force_ask,
+                public_access=public_access,
+        )
+        dbmanage = DbManage(dbconf=dbconf, root=config['here'],
+                            cli_args=cli_args)
+        dbmanage.create_tables(reuse_database=reuse)
+        repo_root_path = dbmanage.prompt_repo_root_path(None)
+        dbmanage.create_settings(repo_root_path)
+        dbmanage.create_default_user()
+        dbmanage.create_admin_user()
+        dbmanage.create_permissions()
+        dbmanage.populate_default_permissions()
+        meta.Session().commit()
 
-    # initial repository scan
-    kallithea.config.middleware.make_app(
-            kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
-    added, _ = kallithea.lib.utils.repo2db_mapper(kallithea.model.scm.ScmModel().repo_scan())
-    if added:
-        click.echo('Initial repository scan: added following repositories:')
-        click.echo('\t%s' % '\n\t'.join(added))
-    else:
-        click.echo('Initial repository scan: no repositories found.')
+    else:  # then called again after app initialization
+        added, _ = kallithea.lib.utils.repo2db_mapper(kallithea.model.scm.ScmModel().repo_scan())
+        if added:
+            click.echo('Initial repository scan: added following repositories:')
+            click.echo('\t%s' % '\n\t'.join(added))
+        else:
+            click.echo('Initial repository scan: no repositories found.')
 
-    click.echo('Database set up successfully.')
-    click.echo("Don't forget to build the front-end using 'kallithea-cli front-end-build'.")
+        click.echo('Database set up successfully.')
+        click.echo("Don't forget to build the front-end using 'kallithea-cli front-end-build'.")

kallithea/bin/kallithea_cli_extensions.py

@@ -24,24 +24,23 b' import os'
 import click
 import pkg_resources
 
-import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.utils2 import ask_ok
 
 
-@cli_base.register_command(config_file=True)
-def extensions_create():
+@cli_base.register_command(needs_config_file=True)
+def extensions_create(config):
     """Write template file for extending Kallithea in Python.
 
-    An rcextensions directory with a __init__.py file will be created next to
-    the ini file. Local customizations in that file will survive upgrades.
-    The file contains instructions on how it can be customized.
+    Create a template `extensions.py` file next to the ini file. Local
+    customizations in that file will survive upgrades. The file contains
+    instructions on how it can be customized.
     """
-    here = kallithea.CONFIG['here']
+    here = config['here']
     content = pkg_resources.resource_string(
-        'kallithea', os.path.join('config', 'rcextensions', '__init__.py')
+        'kallithea', os.path.join('templates', 'py', 'extensions.py')
     )
-    ext_file = os.path.join(here, 'rcextensions', '__init__.py')
+    ext_file = os.path.join(here, 'extensions.py')
     if os.path.exists(ext_file):
         msg = ('Extension file %s already exists, do you want '
                'to overwrite it ? [y/n] ') % ext_file

kallithea/bin/kallithea_cli_iis.py

@@ -16,7 +16,6 b' import sys'
 
 import click
 
-import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 
 
@@ -57,16 +56,16 b" if __name__=='__main__':"
     HandleCommandLine(params)
 '''
 
-@cli_base.register_command(config_file=True)
+@cli_base.register_command(needs_config_file=True)
 @click.option('--virtualdir', default='/',
         help='The virtual folder to install into on IIS.')
-def iis_install(virtualdir):
+def iis_install(virtualdir, config):
     """Install into IIS using isapi-wsgi."""
 
-    config_file_abs = kallithea.CONFIG['__file__']
+    config_file_abs = config['__file__']
 
     try:
-        import isapi_wsgi
+        import isapi_wsgi  # pytype: disable=import-error
         assert isapi_wsgi
     except ImportError:
         sys.stderr.write('missing requirement: isapi-wsgi not installed\n')

kallithea/bin/kallithea_cli_index.py

@@ -28,7 +28,7 b' import kallithea'
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.indexers.daemon import WhooshIndexingDaemon
 from kallithea.lib.pidlock import DaemonLock, LockHeld
-from kallithea.lib.utils import load_rcextensions
+from kallithea.lib.utils import load_extensions
 from kallithea.model.repo import RepoModel
 
 
@@ -41,7 +41,7 b' def index_create(repo_location, index_on'
     """Create or update full text search index"""
 
     index_location = kallithea.CONFIG['index_dir']
-    load_rcextensions(kallithea.CONFIG['here'])
+    load_extensions(kallithea.CONFIG['here'])
 
     if not repo_location:
         repo_location = RepoModel().repos_path

kallithea/bin/kallithea_cli_repo.py

@@ -30,15 +30,18 b' import kallithea'
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper
 from kallithea.lib.utils2 import ask_ok
-from kallithea.model.db import Repository
-from kallithea.model.meta import Session
+from kallithea.model import db, meta
 from kallithea.model.scm import ScmModel
 
 
 @cli_base.register_command(config_file_initialize_app=True)
 @click.option('--remove-missing', is_flag=True,
         help='Remove missing repositories from the Kallithea database.')
-def repo_scan(remove_missing):
[e-mail]('--install-git-hooks', is_flag=True,
+        help='(Re)install Kallithea Git hooks without overwriting other hooks.')
[e-mail]('--overwrite-git-hooks', is_flag=True,
+        help='(Re)install Kallithea Git hooks, overwriting other hooks.')
+def repo_scan(remove_missing, install_git_hooks, overwrite_git_hooks):
     """Scan filesystem for repositories.
 
     Search the configured repository root for new repositories and add them
@@ -49,7 +52,9 b' def repo_scan(remove_missing):'
     """
     click.echo('Now scanning root location for new repos ...')
     added, removed = repo2db_mapper(ScmModel().repo_scan(),
-                                    remove_obsolete=remove_missing)
+                                    remove_obsolete=remove_missing,
+                                    install_git_hooks=install_git_hooks,
+                                    overwrite_git_hooks=overwrite_git_hooks)
     click.echo('Scan completed.')
     if added:
         click.echo('Added: %s' % ', '.join(added))
@@ -73,11 +78,11 b' def repo_update_metadata(repositories):'
     updated.
     """
     if not repositories:
-        repo_list = Repository.query().all()
+        repo_list = db.Repository.query().all()
     else:
         repo_names = [n.strip() for n in repositories]
-        repo_list = list(Repository.query()
-                        .filter(Repository.repo_name.in_(repo_names)))
+        repo_list = list(db.Repository.query()
+                        .filter(db.Repository.repo_name.in_(repo_names)))
 
     for repo in repo_list:
         # update latest revision metadata in database
@@ -86,7 +91,7 b' def repo_update_metadata(repositories):'
         # first access
         repo.set_invalidate()
 
-    Session().commit()
+    meta.Session().commit()
 
     click.echo('Updated database with information about latest change in the following %s repositories:' % (len(repo_list)))
     click.echo('\n'.join(repo.repo_name for repo in repo_list))

kallithea/bin/kallithea_cli_ssh.py

@@ -21,9 +21,9 b' import click'
 
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
-from kallithea.lib.utils2 import str2bool
-from kallithea.lib.vcs.backends.git.ssh import GitSshHandler
-from kallithea.lib.vcs.backends.hg.ssh import MercurialSshHandler
+from kallithea.lib.utils2 import asbool
+from kallithea.lib.vcs.ssh.git import GitSshHandler
+from kallithea.lib.vcs.ssh.hg import MercurialSshHandler
 from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException
 
 
@@ -40,8 +40,7 b' def ssh_serve(user_id, key_id):'
     protocol access. The access will be granted as the specified user ID, and
     logged as using the specified key ID.
     """
-    ssh_enabled = kallithea.CONFIG.get('ssh_enabled', False)
-    if not str2bool(ssh_enabled):
+    if not asbool(kallithea.CONFIG.get('ssh_enabled', False)):
         sys.stderr.write("SSH access is disabled.\n")
         return sys.exit(1)
 
@@ -70,7 +69,7 b' def ssh_serve(user_id, key_id):'
         vcs_handler = VcsHandler.make(ssh_command_parts)
         if vcs_handler is not None:
             vcs_handler.serve(user_id, key_id, client_ip)
-            assert False # serve is written so it never will terminate
+            sys.exit(0)
 
     sys.stderr.write("This account can only be used for repository access. SSH command %r is not supported.\n" % ssh_original_command)
     sys.exit(1)

kallithea/bin/vcs_hooks.py

@@ -12,10 +12,10 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.hooks
-~~~~~~~~~~~~~~~~~~~
+kallithea.bin.vcs_hooks
+~~~~~~~~~~~~~~~~~~~~~~~
 
-Hooks run by Kallithea
+Entry points for Kallithea hooking into Mercurial and Git.
 
 This file was forked by the Kallithea project in July 2014.
 Original author and date, and relevant copyright and licensing information is below:
@@ -25,279 +25,84 b' Original author and date, and relevant c'
 :license: GPLv3, see LICENSE.md for more details.
 """
 
+import logging
 import os
 import sys
-import time
-
-import mercurial.scmutil
 
-from kallithea.lib import helpers as h
-from kallithea.lib.exceptions import UserCreationError
-from kallithea.lib.utils import action_logger, make_ui
+import mercurial.hg
+import mercurial.scmutil
+import paste.deploy
+
+import kallithea
+import kallithea.config.application
+from kallithea.lib import hooks, webutils
 from kallithea.lib.utils2 import HookEnvironmentError, ascii_str, get_hook_environment, safe_bytes, safe_str
 from kallithea.lib.vcs.backends.base import EmptyChangeset
-from kallithea.model.db import Repository, User
+from kallithea.lib.vcs.utils.helpers import get_scm_size
+from kallithea.model import db
 
 
-def _get_scm_size(alias, root_path):
-    if not alias.startswith('.'):
-        alias += '.'
-
-    size_scm, size_root = 0, 0
-    for path, dirs, files in os.walk(root_path):
-        if path.find(alias) != -1:
-            for f in files:
-                try:
-                    size_scm += os.path.getsize(os.path.join(path, f))
-                except OSError:
-                    pass
-        else:
-            for f in files:
-                try:
-                    size_root += os.path.getsize(os.path.join(path, f))
-                except OSError:
-                    pass
-
-    size_scm_f = h.format_byte_size(size_scm)
-    size_root_f = h.format_byte_size(size_root)
-    size_total_f = h.format_byte_size(size_root + size_scm)
-
-    return size_scm_f, size_root_f, size_total_f
+log = logging.getLogger(__name__)
 
 
 def repo_size(ui, repo, hooktype=None, **kwargs):
     """Show size of Mercurial repository.
 
-    Called as Mercurial hook changegroup.repo_size after push.
+    Called as Mercurial hook changegroup.kallithea_repo_size after push.
     """
-    size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', safe_str(repo.root))
+    size_hg, size_root = get_scm_size('.hg', safe_str(repo.root))
 
     last_cs = repo[len(repo) - 1]
 
     msg = ('Repository size .hg: %s Checkout: %s Total: %s\n'
            'Last revision is now r%s:%s\n') % (
-        size_hg_f, size_root_f, size_total_f, last_cs.rev(), ascii_str(last_cs.hex())[:12]
+        webutils.format_byte_size(size_hg),
+        webutils.format_byte_size(size_root),
+        webutils.format_byte_size(size_hg + size_root),
+        last_cs.rev(),
+        ascii_str(last_cs.hex())[:12],
     )
     ui.status(safe_bytes(msg))
 
 
-def log_pull_action(ui, repo, **kwargs):
-    """Logs user last pull action
-
-    Called as Mercurial hook outgoing.pull_logger or from Kallithea before invoking Git.
-
-    Does *not* use the action from the hook environment but is always 'pull'.
-    """
-    ex = get_hook_environment()
+def update(ui, repo, hooktype=None, **kwargs):
+    """Update repo after push. The equivalent to 'hg update' but using the same
+    Mercurial as everything else.
 
-    user = User.get_by_username(ex.username)
-    action = 'pull'
-    action_logger(user, action, ex.repository, ex.ip, commit=True)
-    # extension hook call
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'PULL_HOOK', None)
-    if callable(callback):
-        kw = {}
-        kw.update(ex)
-        callback(**kw)
-
-    return 0
+    Called as Mercurial hook changegroup.kallithea_update after push.
+    """
+    try:
+        ui.pushbuffer(error=True, subproc=True)
+        rev = brev = None
+        mercurial.hg.updatetotally(ui, repo, rev, brev)
+    finally:
+        s = ui.popbuffer()  # usually just "x files updated, x files merged, x files removed, x files unresolved"
+        log.info('%s update hook output: %s', safe_str(repo.root), safe_str(s).rstrip())
 
 
-def log_push_action(ui, repo, node, node_last, **kwargs):
+def pull_action(ui, repo, **kwargs):
+    """Logs user pull action
+
+    Called as Mercurial hook outgoing.kallithea_pull_action.
+    """
+    hooks.log_pull_action()
+
+
+def push_action(ui, repo, node, node_last, **kwargs):
     """
     Register that changes have been added to the repo - log the action *and* invalidate caches.
     Note: This hook is not only logging, but also the side effect invalidating
     caches! The function should perhaps be renamed.
 
-    Called as Mercurial hook changegroup.kallithea_log_push_action .
+    Called as Mercurial hook changegroup.kallithea_push_action .
 
     The pushed changesets is given by the revset 'node:node_last'.
     """
     revs = [ascii_str(repo[r].hex()) for r in mercurial.scmutil.revrange(repo, [b'%s:%s' % (node, node_last)])]
-    process_pushed_raw_ids(revs)
-    return 0
-
-
-def process_pushed_raw_ids(revs):
-    """
-    Register that changes have been added to the repo - log the action *and* invalidate caches.
-
-    Called from Mercurial changegroup.kallithea_log_push_action calling hook log_push_action,
-    or from the Git post-receive hook calling handle_git_post_receive ...
-    or from scm _handle_push.
-    """
-    ex = get_hook_environment()
-
-    action = '%s:%s' % (ex.action, ','.join(revs))
-    action_logger(ex.username, action, ex.repository, ex.ip, commit=True)
-
-    from kallithea.model.scm import ScmModel
-    ScmModel().mark_for_invalidation(ex.repository)
-
-    # extension hook call
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)
-    if callable(callback):
-        kw = {'pushed_revs': revs}
-        kw.update(ex)
-        callback(**kw)
-
-
-def log_create_repository(repository_dict, created_by, **kwargs):
-    """
-    Post create repository Hook.
-
-    :param repository: dict dump of repository object
-    :param created_by: username who created repository
-
-    available keys of repository_dict:
-
-     'repo_type',
-     'description',
-     'private',
-     'created_on',
-     'enable_downloads',
-     'repo_id',
-     'owner_id',
-     'enable_statistics',
-     'clone_uri',
-     'fork_id',
-     'group_id',
-     'repo_name'
-
-    """
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'CREATE_REPO_HOOK', None)
-    if callable(callback):
-        kw = {}
-        kw.update(repository_dict)
-        kw.update({'created_by': created_by})
-        kw.update(kwargs)
-        return callback(**kw)
-
-    return 0
-
-
-def check_allowed_create_user(user_dict, created_by, **kwargs):
-    # pre create hooks
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'PRE_CREATE_USER_HOOK', None)
-    if callable(callback):
-        allowed, reason = callback(created_by=created_by, **user_dict)
-        if not allowed:
-            raise UserCreationError(reason)
+    hooks.process_pushed_raw_ids(revs)
 
 
-def log_create_user(user_dict, created_by, **kwargs):
-    """
-    Post create user Hook.
-
-    :param user_dict: dict dump of user object
-
-    available keys for user_dict:
-
-     'username',
-     'full_name_or_username',
-     'full_contact',
-     'user_id',
-     'name',
-     'firstname',
-     'short_contact',
-     'admin',
-     'lastname',
-     'ip_addresses',
-     'ldap_dn',
-     'email',
-     'api_key',
-     'last_login',
-     'full_name',
-     'active',
-     'password',
-     'emails',
-
-    """
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'CREATE_USER_HOOK', None)
-    if callable(callback):
-        return callback(created_by=created_by, **user_dict)
-
-    return 0
-
-
-def log_delete_repository(repository_dict, deleted_by, **kwargs):
-    """
-    Post delete repository Hook.
-
-    :param repository: dict dump of repository object
-    :param deleted_by: username who deleted the repository
-
-    available keys of repository_dict:
-
-     'repo_type',
-     'description',
-     'private',
-     'created_on',
-     'enable_downloads',
-     'repo_id',
-     'owner_id',
-     'enable_statistics',
-     'clone_uri',
-     'fork_id',
-     'group_id',
-     'repo_name'
-
-    """
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'DELETE_REPO_HOOK', None)
-    if callable(callback):
-        kw = {}
-        kw.update(repository_dict)
-        kw.update({'deleted_by': deleted_by,
-                   'deleted_on': time.time()})
-        kw.update(kwargs)
-        return callback(**kw)
-
-    return 0
-
-
-def log_delete_user(user_dict, deleted_by, **kwargs):
-    """
-    Post delete user Hook.
-
-    :param user_dict: dict dump of user object
-
-    available keys for user_dict:
-
-     'username',
-     'full_name_or_username',
-     'full_contact',
-     'user_id',
-     'name',
-     'firstname',
-     'short_contact',
-     'admin',
-     'lastname',
-     'ip_addresses',
-     'ldap_dn',
-     'email',
-     'api_key',
-     'last_login',
-     'full_name',
-     'active',
-     'password',
-     'emails',
-
-    """
-    from kallithea import EXTENSIONS
-    callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None)
-    if callable(callback):
-        return callback(deleted_by=deleted_by, **user_dict)
-
-    return 0
-
-
-def _hook_environment(repo_path):
+def _git_hook_environment(repo_path):
     """
     Create a light-weight environment for stand-alone scripts and return an UI and the
     db repository.
@@ -306,40 +111,32 b' def _hook_environment(repo_path):'
     they thus need enough info to be able to create an app environment and
     connect to the database.
     """
-    import paste.deploy
-    import kallithea.config.middleware
-
     extras = get_hook_environment()
 
     path_to_ini_file = extras['config']
-    kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)
+    config = paste.deploy.appconfig('config:' + path_to_ini_file)
     #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging
-    kallithea.config.middleware.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
+    kallithea.config.application.make_app(config.global_conf, **config.local_conf)
 
     # fix if it's not a bare repo
     if repo_path.endswith(os.sep + '.git'):
         repo_path = repo_path[:-5]
 
-    repo = Repository.get_by_full_path(repo_path)
+    repo = db.Repository.get_by_full_path(repo_path)
     if not repo:
         raise OSError('Repository %s not found in database' % repo_path)
 
-    baseui = make_ui()
-    return baseui, repo
+    return repo
 
 
-def handle_git_pre_receive(repo_path, git_stdin_lines):
-    """Called from Git pre-receive hook"""
-    # Currently unused. TODO: remove?
-    return 0
-
-
-def handle_git_post_receive(repo_path, git_stdin_lines):
-    """Called from Git post-receive hook"""
+def post_receive(repo_path, git_stdin_lines):
+    """Called from Git post-receive hook.
+    The returned value is used as hook exit code and must be 0.
+    """
     try:
-        baseui, repo = _hook_environment(repo_path)
+        repo = _git_hook_environment(repo_path)
     except HookEnvironmentError as e:
-        sys.stderr.write("Skipping Kallithea Git post-recieve hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))
+        sys.stderr.write("Skipping Kallithea Git post-receive hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))
         return 0
 
     # the post push hook should never use the cached instance
@@ -391,14 +188,16 b' def handle_git_post_receive(repo_path, g'
         elif _type == 'tags':
             git_revs += ['tag=>%s' % push_ref['name']]
 
-    process_pushed_raw_ids(git_revs)
+    hooks.process_pushed_raw_ids(git_revs)
 
     return 0
 
 
 # Almost exactly like Mercurial contrib/hg-ssh:
 def rejectpush(ui, **kwargs):
-    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos"""
+    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos.
+    Return value 1 will make the hook fail and reject the push.
+    """
     ex = get_hook_environment()
     ui.warn(safe_bytes("Push access to %r denied\n" % ex.repository))
     return 1

kallithea/config/app_cfg.py

@@ -28,82 +28,57 b' import tg'
 from alembic.migration import MigrationContext
 from alembic.script.base import ScriptDirectory
 from sqlalchemy import create_engine
-from tg.configuration import AppConfig
-from tg.support.converters import asbool
+from tg import FullStackApplicationConfigurator
 
-import kallithea.lib.locale
+import kallithea.lib.locales
 import kallithea.model.base
 import kallithea.model.meta
-from kallithea.lib import celerypylons
-from kallithea.lib.middleware.https_fixup import HttpsFixup
-from kallithea.lib.middleware.permanent_repo_url import PermanentRepoUrl
-from kallithea.lib.middleware.simplegit import SimpleGit
-from kallithea.lib.middleware.simplehg import SimpleHg
-from kallithea.lib.middleware.wrapper import RequestWrapper
-from kallithea.lib.utils import check_git_version, load_rcextensions, set_app_settings, set_indexer_config, set_vcs_config
-from kallithea.lib.utils2 import str2bool
+from kallithea.lib import celery_app
+from kallithea.lib.utils import load_extensions, set_app_settings, set_indexer_config, set_vcs_config
+from kallithea.lib.utils2 import asbool, check_git_version
 from kallithea.model import db
 
 
 log = logging.getLogger(__name__)
 
 
-class KallitheaAppConfig(AppConfig):
-    # Note: AppConfig has a misleading name, as it's not the application
-    # configuration, but the application configurator. The AppConfig values are
-    # used as a template to create the actual configuration, which might
-    # overwrite or extend the one provided by the configurator template.
+base_config = FullStackApplicationConfigurator()
 
-    # To make it clear, AppConfig creates the config and sets into it the same
-    # values that AppConfig itself has. Then the values from the config file and
-    # gearbox options are loaded and merged into the configuration. Then an
-    # after_init_config(conf) method of AppConfig is called for any change that
-    # might depend on options provided by configuration files.
+base_config.update_blueprint({
+    'package': kallithea,
 
-    def __init__(self):
-        super(KallitheaAppConfig, self).__init__()
-
-        self['package'] = kallithea
+    # Rendering Engines Configuration
+    'renderers': [
+        'json',
+        'mako',
+    ],
+    'default_renderer': 'mako',
+    'use_dotted_templatenames': False,
 
-        self['prefer_toscawidgets2'] = False
-        self['use_toscawidgets'] = False
-
-        self['renderers'] = []
-
-        # Enable json in expose
-        self['renderers'].append('json')
+    # Configure Sessions, store data as JSON to avoid pickle security issues
+    'session.enabled': True,
+    'session.data_serializer': 'json',
 
-        # Configure template rendering
-        self['renderers'].append('mako')
-        self['default_renderer'] = 'mako'
-        self['use_dotted_templatenames'] = False
+    # Configure the base SQLALchemy Setup
+    'use_sqlalchemy': True,
+    'model': kallithea.model.base,
+    'DBSession': kallithea.model.meta.Session,
 
-        # Configure Sessions, store data as JSON to avoid pickle security issues
-        self['session.enabled'] = True
-        self['session.data_serializer'] = 'json'
-
-        # Configure the base SQLALchemy Setup
-        self['use_sqlalchemy'] = True
-        self['model'] = kallithea.model.base
-        self['DBSession'] = kallithea.model.meta.Session
+    # Configure App without an authentication backend.
+    'auth_backend': None,
 
-        # Configure App without an authentication backend.
-        self['auth_backend'] = None
-
-        # Use custom error page for these errors. By default, Turbogears2 does not add
-        # 400 in this list.
-        # Explicitly listing all is considered more robust than appending to defaults,
-        # in light of possible future framework changes.
-        self['errorpage.status_codes'] = [400, 401, 403, 404]
+    # Use custom error page for these errors. By default, Turbogears2 does not add
+    # 400 in this list.
+    # Explicitly listing all is considered more robust than appending to defaults,
+    # in light of possible future framework changes.
+    'errorpage.status_codes': [400, 401, 403, 404],
 
-        # Disable transaction manager -- currently Kallithea takes care of transactions itself
-        self['tm.enabled'] = False
+    # Disable transaction manager -- currently Kallithea takes care of transactions itself
+    'tm.enabled': False,
 
-        # Set the default i18n source language so TG doesn't search beyond 'en' in Accept-Language.
-        self['i18n.lang'] = 'en'
-
-
-base_config = KallitheaAppConfig()
+    # Set the default i18n source language so TG doesn't search beyond 'en' in Accept-Language.
+    'i18n.lang': 'en',
+})
 
 # DebugBar, a debug toolbar for TurboGears2.
 # (https://github.com/TurboGears/tgext.debugbar)
@@ -111,20 +86,20 b' base_config = KallitheaAppConfig()'
 # 'debug = true' (not in production!)
 # See the Kallithea documentation for more information.
 try:
+    import kajiki  # only to check its existence
     from tgext.debugbar import enable_debugbar
-    import kajiki # only to check its existence
     assert kajiki
 except ImportError:
     pass
 else:
-    base_config['renderers'].append('kajiki')
+    base_config.get_blueprint_value('renderers').append('kajiki')
     enable_debugbar(base_config)
 
 
 def setup_configuration(app):
     config = app.config
 
-    if not kallithea.lib.locale.current_locale_is_valid():
+    if not kallithea.lib.locales.current_locale_is_valid():
         log.error("Terminating ...")
         sys.exit(1)
 
@@ -134,7 +109,7 b' def setup_configuration(app):'
         mercurial.encoding.encoding = hgencoding
 
     if config.get('ignore_alembic_revision', False):
-        log.warn('database alembic revision checking is disabled')
+        log.warning('database alembic revision checking is disabled')
     else:
         dbconf = config['sqlalchemy.url']
         alembic_cfg = alembic.config.Config()
@@ -160,11 +135,11 b' def setup_configuration(app):'
     # store some globals into kallithea
     kallithea.DEFAULT_USER_ID = db.User.get_default_user().user_id
 
-    if str2bool(config.get('use_celery')):
-        kallithea.CELERY_APP = celerypylons.make_app()
+    if asbool(config.get('use_celery')) and not kallithea.CELERY_APP.finalized:
+        kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))
     kallithea.CONFIG = config
 
-    load_rcextensions(root_path=config['here'])
+    load_extensions(root_path=config['here'])
 
     set_app_settings(config)
 
@@ -188,27 +163,3 b' def setup_configuration(app):'
 
 
 tg.hooks.register('configure_new_app', setup_configuration)
-
-
-def setup_application(app):
-    config = app.config
-
-    # we want our low level middleware to get to the request ASAP. We don't
-    # need any stack middleware in them - especially no StatusCodeRedirect buffering
-    app = SimpleHg(app, config)
-    app = SimpleGit(app, config)
-
-    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
-    if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
-        app = HttpsFixup(app, config)
-
-    app = PermanentRepoUrl(app, config)
-
-    # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead
-    if str2bool(config.get('use_wsgi_wrapper')):
-        app = RequestWrapper(app, config)
-
-    return app
-
-
-tg.hooks.register('before_config', setup_application)

kallithea/config/application.py

@@ -14,26 +14,46 b''
 """WSGI middleware initialization for the Kallithea application."""
 
 from kallithea.config.app_cfg import base_config
-from kallithea.config.environment import load_environment
+from kallithea.config.middleware.https_fixup import HttpsFixup
+from kallithea.config.middleware.permanent_repo_url import PermanentRepoUrl
+from kallithea.config.middleware.simplegit import SimpleGit
+from kallithea.config.middleware.simplehg import SimpleHg
+from kallithea.config.middleware.wrapper import RequestWrapper
+from kallithea.lib.utils2 import asbool
 
 
 __all__ = ['make_app']
 
-# Use base_config to setup the necessary PasteDeploy application factory.
-# make_base_app will wrap the TurboGears2 app with all the middleware it needs.
-make_base_app = base_config.setup_tg_wsgi_app(load_environment)
+
+def wrap_app(app):
+    """Wrap the TG WSGI application in Kallithea middleware"""
+    config = app.config
+
+    # we want our low level middleware to get to the request ASAP. We don't
+    # need any stack middleware in them - especially no StatusCodeRedirect buffering
+    app = SimpleHg(app, config)
+    app = SimpleGit(app, config)
+
+    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
+    if any(asbool(config.get(x)) for x in ['url_scheme_variable', 'force_https', 'use_htsts']):
+        app = HttpsFixup(app, config)
+
+    app = PermanentRepoUrl(app, config)
+
+    # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead
+    if asbool(config.get('use_wsgi_wrapper')):
+        app = RequestWrapper(app, config)
+
+    return app
 
 
-def make_app(global_conf, full_stack=True, **app_conf):
+def make_app(global_conf, **app_conf):
     """
     Set up Kallithea with the settings found in the PasteDeploy configuration
     file used.
 
     :param global_conf: The global settings for Kallithea (those
         defined under the ``[DEFAULT]`` section).
-    :type global_conf: dict
-    :param full_stack: Should the whole TurboGears2 stack be set up?
-    :type full_stack: str or bool
     :return: The Kallithea application with all the relevant middleware
         loaded.
 
@@ -44,4 +64,5 b' def make_app(global_conf, full_stack=Tru'
     """
     assert app_conf.get('sqlalchemy.url')  # must be called with a Kallithea .ini file, which for example must have this config option
     assert global_conf.get('here') and global_conf.get('__file__')  # app config should be initialized the paste way ...
-    return make_base_app(global_conf, full_stack=full_stack, **app_conf)
+
+    return base_config.make_wsgi_app(global_conf, app_conf, wrap_app=wrap_app)

kallithea/config/middleware/https_fixup.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.https_fixup
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.https_fixup
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 middleware to handle https correctly
 
@@ -26,7 +26,8 b' Original author and date, and relevant c'
 """
 
 
-from kallithea.lib.utils2 import str2bool
+import kallithea
+from kallithea.lib.utils2 import asbool
 
 
 class HttpsFixup(object):
@@ -37,11 +38,11 b' class HttpsFixup(object):'
 
     def __call__(self, environ, start_response):
         self.__fixup(environ)
-        debug = str2bool(self.config.get('debug'))
+        debug = asbool(self.config.get('debug'))
         is_ssl = environ['wsgi.url_scheme'] == 'https'
 
         def custom_start_response(status, headers, exc_info=None):
-            if is_ssl and str2bool(self.config.get('use_htsts')) and not debug:
+            if is_ssl and asbool(self.config.get('use_htsts')) and not debug:
                 headers.append(('Strict-Transport-Security',
                                 'max-age=8640000; includeSubDomains'))
             return start_response(status, headers, exc_info)
@@ -54,20 +55,17 b' class HttpsFixup(object):'
         middleware you should set this header inside your
         proxy ie. nginx, apache etc.
         """
-        # DETECT PROTOCOL !
-        if 'HTTP_X_URL_SCHEME' in environ:
-            proto = environ.get('HTTP_X_URL_SCHEME')
-        elif 'HTTP_X_FORWARDED_SCHEME' in environ:
-            proto = environ.get('HTTP_X_FORWARDED_SCHEME')
-        elif 'HTTP_X_FORWARDED_PROTO' in environ:
-            proto = environ.get('HTTP_X_FORWARDED_PROTO')
-        else:
-            proto = 'http'
-        org_proto = proto
+        proto = None
 
         # if we have force, just override
-        if str2bool(self.config.get('force_https')):
+        if asbool(self.config.get('force_https')):
             proto = 'https'
+        else:
+            # get protocol from configured WSGI environment variable
+            url_scheme_variable = kallithea.CONFIG.get('url_scheme_variable')
+            if url_scheme_variable:
+                proto = environ.get(url_scheme_variable)
 
-        environ['wsgi.url_scheme'] = proto
-        environ['wsgi._org_proto'] = org_proto
+        if proto:
+            environ['wsgi._org_proto'] = environ.get('wsgi.url_scheme')
+            environ['wsgi.url_scheme'] = proto

kallithea/config/middleware/permanent_repo_url.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.permanent_repo_url
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.permanent_repo_url
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 middleware to handle permanent repo URLs, replacing PATH_INFO '/_123/yada' with
 '/name/of/repo/yada' after looking 123 up in the database.

kallithea/config/middleware/pygrack.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.pygrack
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.pygrack
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Python implementation of git-http-backend's Smart HTTP protocol
 
@@ -30,11 +30,13 b' import os'
 import socket
 import traceback
 
+from dulwich.server import update_server_info
+from dulwich.web import GunzipFilter, LimitedInputFilter
 from webob import Request, Response, exc
 
 import kallithea
 from kallithea.lib.utils2 import ascii_bytes
-from kallithea.lib.vcs import subprocessio
+from kallithea.lib.vcs import get_repo, subprocessio
 
 
 log = logging.getLogger(__name__)
@@ -168,8 +170,6 b' class GitRepository(object):'
         if git_command in ['git-receive-pack']:
             # updating refs manually after each push.
             # Needed for pre-1.7.0.4 git clients using regular HTTP mode.
-            from kallithea.lib.vcs import get_repo
-            from dulwich.server import update_server_info
             repo = get_repo(self.content_path)
             if repo:
                 update_server_info(repo._repo)
@@ -223,6 +223,5 b' class GitDirectory(object):'
 
 
 def make_wsgi_app(repo_name, repo_root):
-    from dulwich.web import LimitedInputFilter, GunzipFilter
     app = GitDirectory(repo_root, repo_name)
     return GunzipFilter(LimitedInputFilter(app))

kallithea/config/middleware/simplegit.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.simplegit
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.simplegit
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 SimpleGit middleware for handling Git protocol requests (push/clone etc.)
 It's implemented with basic auth function
@@ -31,11 +31,9 b' Original author and date, and relevant c'
 import logging
 import re
 
-from kallithea.lib.base import BaseVCSController, get_path_info
-from kallithea.lib.hooks import log_pull_action
-from kallithea.lib.middleware.pygrack import make_wsgi_app
-from kallithea.lib.utils import make_ui
-from kallithea.model.db import Repository
+from kallithea.config.middleware.pygrack import make_wsgi_app
+from kallithea.controllers import base
+from kallithea.lib import hooks
 
 
 log = logging.getLogger(__name__)
@@ -50,13 +48,13 b' cmd_mapping = {'
 }
 
 
-class SimpleGit(BaseVCSController):
+class SimpleGit(base.BaseVCSController):
 
     scm_alias = 'git'
 
     @classmethod
     def parse_request(cls, environ):
-        path_info = get_path_info(environ)
+        path_info = base.get_path_info(environ)
         m = GIT_PROTO_PAT.match(path_info)
         if m is None:
             return None
@@ -86,11 +84,8 b' class SimpleGit(BaseVCSController):'
             if (parsed_request.cmd == 'info/refs' and
                 parsed_request.service == 'git-upload-pack'
             ):
-                baseui = make_ui()
-                repo = Repository.get_by_repo_name(parsed_request.repo_name)
-                scm_repo = repo.scm_instance
-                # Run hooks, like Mercurial outgoing.pull_logger does
-                log_pull_action(ui=baseui, repo=scm_repo._repo)
+                # Run hooks like Mercurial outgoing.kallithea_pull_action does
+                hooks.log_pull_action()
             # Note: push hooks are handled by post-receive hook
 
             return pygrack_app(environ, start_response)

kallithea/config/middleware/simplehg.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.simplehg
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.simplehg
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 SimpleHg middleware for handling Mercurial protocol requests (push/clone etc.).
 It's implemented with basic auth function
@@ -34,7 +34,7 b' import urllib.parse'
 
 import mercurial.hgweb
 
-from kallithea.lib.base import BaseVCSController, get_path_info
+from kallithea.controllers import base
 from kallithea.lib.utils import make_ui
 from kallithea.lib.utils2 import safe_bytes
 
@@ -91,7 +91,7 b' cmd_mapping = {'
     }
 
 
-class SimpleHg(BaseVCSController):
+class SimpleHg(base.BaseVCSController):
 
     scm_alias = 'hg'
 
@@ -100,7 +100,7 b' class SimpleHg(BaseVCSController):'
         http_accept = environ.get('HTTP_ACCEPT', '')
         if not http_accept.startswith('application/mercurial'):
             return None
-        path_info = get_path_info(environ)
+        path_info = base.get_path_info(environ)
         if not path_info.startswith('/'): # it must!
             return None
 

kallithea/config/middleware/wrapper.py

@@ -12,8 +12,8 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.middleware.wrapper
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+kallithea.config.middleware.wrapper
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Wrap app to measure request and response time ... all the way to the response
 WSGI iterator has been closed.
@@ -29,7 +29,7 b' Original author and date, and relevant c'
 import logging
 import time
 
-from kallithea.lib.base import _get_ip_addr, get_path_info
+from kallithea.controllers import base
 
 
 log = logging.getLogger(__name__)
@@ -91,8 +91,8 b' class RequestWrapper(object):'
     def __call__(self, environ, start_response):
         meter = Meter(start_response)
         description = "Request from %s for %s" % (
-            _get_ip_addr(environ),
-            get_path_info(environ),
+            base.get_ip_addr(environ),
+            base.get_path_info(environ),
         )
         log.info("%s received", description)
         try:

kallithea/controllers/admin/admin.py

@@ -36,12 +36,12 b' from whoosh import query'
 from whoosh.qparser.dateparse import DateParserPlugin
 from whoosh.qparser.default import QueryParser
 
+from kallithea.controllers import base
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
 from kallithea.lib.indexers import JOURNAL_SCHEMA
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import remove_prefix, remove_suffix, safe_int
-from kallithea.model.db import UserLog
+from kallithea.model import db
 
 
 log = logging.getLogger(__name__)
@@ -77,15 +77,15 b' def _journal_filter(user_log, search_ter'
     def get_filterion(field, val, term):
 
         if field == 'repository':
-            field = getattr(UserLog, 'repository_name')
+            field = getattr(db.UserLog, 'repository_name')
         elif field == 'ip':
-            field = getattr(UserLog, 'user_ip')
+            field = getattr(db.UserLog, 'user_ip')
         elif field == 'date':
-            field = getattr(UserLog, 'action_date')
+            field = getattr(db.UserLog, 'action_date')
         elif field == 'username':
-            field = getattr(UserLog, 'username')
+            field = getattr(db.UserLog, 'username')
         else:
-            field = getattr(UserLog, field)
+            field = getattr(db.UserLog, field)
         log.debug('filter field: %s val=>%s', field, val)
 
         # sql filtering
@@ -102,6 +102,7 b' def _journal_filter(user_log, search_ter'
         if not isinstance(qry, query.And):
             qry = [qry]
         for term in qry:
+            assert term is not None, term
             field = term.fieldname
             val = (term.text if not isinstance(term, query.DateRange)
                    else [term.startdate, term.enddate])
@@ -118,7 +119,7 b' def _journal_filter(user_log, search_ter'
     return user_log
 
 
-class AdminController(BaseController):
+class AdminController(base.BaseController):
 
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
@@ -126,15 +127,15 b' class AdminController(BaseController):'
 
     @HasPermissionAnyDecorator('hg.admin')
     def index(self):
-        users_log = UserLog.query() \
-                .options(joinedload(UserLog.user)) \
-                .options(joinedload(UserLog.repository))
+        users_log = db.UserLog.query() \
+                .options(joinedload(db.UserLog.user)) \
+                .options(joinedload(db.UserLog.repository))
 
         # FILTERING
         c.search_term = request.GET.get('filter')
         users_log = _journal_filter(users_log, c.search_term)
 
-        users_log = users_log.order_by(UserLog.action_date.desc())
+        users_log = users_log.order_by(db.UserLog.action_date.desc())
 
         p = safe_int(request.GET.get('page'), 1)
 
@@ -142,6 +143,6 b' class AdminController(BaseController):'
                            filter=c.search_term)
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('admin/admin_log.html')
+            return base.render('admin/admin_log.html')
 
-        return render('admin/admin.html')
+        return base.render('admin/admin.html')

kallithea/controllers/admin/auth_settings.py

@@ -32,20 +32,18 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 
-from kallithea.config.routing import url
-from kallithea.lib import auth_modules
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import auth_modules, webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
-from kallithea.model.db import Setting
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import AuthSettingsForm
-from kallithea.model.meta import Session
 
 
 log = logging.getLogger(__name__)
 
 
-class AuthSettingsController(BaseController):
+class AuthSettingsController(base.BaseController):
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
@@ -77,7 +75,7 b' class AuthSettingsController(BaseControl'
                 if "default" in v:
                     c.defaults[fullname] = v["default"]
                 # Current values will be the default on the form, if there are any
-                setting = Setting.get_by_name(fullname)
+                setting = db.Setting.get_by_name(fullname)
                 if setting is not None:
                     c.defaults[fullname] = setting.app_settings_value
         if defaults:
@@ -88,7 +86,7 b' class AuthSettingsController(BaseControl'
 
         log.debug('defaults: %s', defaults)
         return formencode.htmlfill.render(
-            render('admin/auth/auth_settings.html'),
+            base.render('admin/auth/auth_settings.html'),
             defaults=c.defaults,
             errors=errors,
             prefix_error=False,
@@ -131,9 +129,9 b' class AuthSettingsController(BaseControl'
                     # we want to store it comma separated inside our settings
                     v = ','.join(v)
                 log.debug("%s = %s", k, str(v))
-                setting = Setting.create_or_update(k, v)
-            Session().commit()
-            h.flash(_('Auth settings updated successfully'),
+                setting = db.Setting.create_or_update(k, v)
+            meta.Session().commit()
+            webutils.flash(_('Auth settings updated successfully'),
                        category='success')
         except formencode.Invalid as errors:
             log.error(traceback.format_exc())
@@ -144,7 +142,7 b' class AuthSettingsController(BaseControl'
             )
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('error occurred during update of auth settings'),
+            webutils.flash(_('error occurred during update of auth settings'),
                     category='error')
 
         raise HTTPFound(location=url('auth_home'))

kallithea/controllers/admin/defaults.py

@@ -34,19 +34,18 b' from tg import request'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
-from kallithea.model.db import Setting
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import DefaultsForm
-from kallithea.model.meta import Session
 
 
 log = logging.getLogger(__name__)
 
 
-class DefaultsController(BaseController):
+class DefaultsController(base.BaseController):
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
@@ -54,10 +53,10 b' class DefaultsController(BaseController)'
         super(DefaultsController, self)._before(*args, **kwargs)
 
     def index(self, format='html'):
-        defaults = Setting.get_default_repo_settings()
+        defaults = db.Setting.get_default_repo_settings()
 
         return htmlfill.render(
-            render('admin/defaults/defaults.html'),
+            base.render('admin/defaults/defaults.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -69,16 +68,16 b' class DefaultsController(BaseController)'
         try:
             form_result = _form.to_python(dict(request.POST))
             for k, v in form_result.items():
-                setting = Setting.create_or_update(k, v)
-            Session().commit()
-            h.flash(_('Default settings updated successfully'),
+                setting = db.Setting.create_or_update(k, v)
+            meta.Session().commit()
+            webutils.flash(_('Default settings updated successfully'),
                     category='success')
 
         except formencode.Invalid as errors:
             defaults = errors.value
 
             return htmlfill.render(
-                render('admin/defaults/defaults.html'),
+                base.render('admin/defaults/defaults.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -86,7 +85,7 b' class DefaultsController(BaseController)'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of defaults'),
+            webutils.flash(_('Error occurred during update of defaults'),
                     category='error')
 
         raise HTTPFound(location=url('defaults'))

kallithea/controllers/admin/gists.py

@@ -35,24 +35,22 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import auth, webutils
 from kallithea.lib.auth import LoginRequired
-from kallithea.lib.base import BaseController, jsonify, render
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int, safe_str, time_to_datetime
 from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError
-from kallithea.model.db import Gist
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import GistForm
 from kallithea.model.gist import GistModel
-from kallithea.model.meta import Session
 
 
 log = logging.getLogger(__name__)
 
 
-class GistsController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
+class GistsController(base.BaseController):
 
     def __load_defaults(self, extra_values=None):
         c.lifetime_values = [
@@ -77,34 +75,34 b' class GistsController(BaseController):'
         elif c.show_private:
             url_params['private'] = 1
 
-        gists = Gist().query() \
+        gists = db.Gist().query() \
             .filter_by(is_expired=False) \
-            .order_by(Gist.created_on.desc())
+            .order_by(db.Gist.created_on.desc())
 
         # MY private
         if c.show_private and not c.show_public:
-            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \
-                             .filter(Gist.owner_id == request.authuser.user_id)
+            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PRIVATE) \
+                             .filter(db.Gist.owner_id == request.authuser.user_id)
         # MY public
         elif c.show_public and not c.show_private:
-            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \
-                             .filter(Gist.owner_id == request.authuser.user_id)
+            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PUBLIC) \
+                             .filter(db.Gist.owner_id == request.authuser.user_id)
 
         # MY public+private
         elif c.show_private and c.show_public:
-            gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
-                                     Gist.gist_type == Gist.GIST_PRIVATE)) \
-                             .filter(Gist.owner_id == request.authuser.user_id)
+            gists = gists.filter(or_(db.Gist.gist_type == db.Gist.GIST_PUBLIC,
+                                     db.Gist.gist_type == db.Gist.GIST_PRIVATE)) \
+                             .filter(db.Gist.owner_id == request.authuser.user_id)
 
         # default show ALL public gists
         if not c.show_public and not c.show_private:
-            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
+            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PUBLIC)
 
         c.gists = gists
         p = safe_int(request.GET.get('page'), 1)
         c.gists_pager = Page(c.gists, page=p, items_per_page=10,
                              **url_params)
-        return render('admin/gists/index.html')
+        return base.render('admin/gists/index.html')
 
     @LoginRequired()
     def create(self):
@@ -113,7 +111,7 b' class GistsController(BaseController):'
         try:
             form_result = gist_form.to_python(dict(request.POST))
             # TODO: multiple files support, from the form
-            filename = form_result['filename'] or Gist.DEFAULT_FILENAME
+            filename = form_result['filename'] or db.Gist.DEFAULT_FILENAME
             nodes = {
                 filename: {
                     'content': form_result['content'],
@@ -121,7 +119,7 b' class GistsController(BaseController):'
                 }
             }
             _public = form_result['public']
-            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE
+            gist_type = db.Gist.GIST_PUBLIC if _public else db.Gist.GIST_PRIVATE
             gist = GistModel().create(
                 description=form_result['description'],
                 owner=request.authuser.user_id,
@@ -130,13 +128,13 b' class GistsController(BaseController):'
                 gist_type=gist_type,
                 lifetime=form_result['lifetime']
             )
-            Session().commit()
+            meta.Session().commit()
             new_gist_id = gist.gist_access_id
         except formencode.Invalid as errors:
             defaults = errors.value
 
             return formencode.htmlfill.render(
-                render('admin/gists/new.html'),
+                base.render('admin/gists/new.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -145,23 +143,23 b' class GistsController(BaseController):'
 
         except Exception as e:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during gist creation'), category='error')
+            webutils.flash(_('Error occurred during gist creation'), category='error')
             raise HTTPFound(location=url('new_gist'))
         raise HTTPFound(location=url('gist', gist_id=new_gist_id))
 
     @LoginRequired()
     def new(self, format='html'):
         self.__load_defaults()
-        return render('admin/gists/new.html')
+        return base.render('admin/gists/new.html')
 
     @LoginRequired()
     def delete(self, gist_id):
         gist = GistModel().get_gist(gist_id)
         owner = gist.owner_id == request.authuser.user_id
-        if h.HasPermissionAny('hg.admin')() or owner:
+        if auth.HasPermissionAny('hg.admin')() or owner:
             GistModel().delete(gist)
-            Session().commit()
-            h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')
+            meta.Session().commit()
+            webutils.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')
         else:
             raise HTTPForbidden()
 
@@ -169,7 +167,7 b' class GistsController(BaseController):'
 
     @LoginRequired(allow_default_user=True)
     def show(self, gist_id, revision='tip', format='html', f_path=None):
-        c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
 
         if c.gist.is_expired:
             log.error('Gist expired at %s',
@@ -188,11 +186,11 b' class GistsController(BaseController):'
             )
             response.content_type = 'text/plain'
             return content
-        return render('admin/gists/show.html')
+        return base.render('admin/gists/show.html')
 
     @LoginRequired()
     def edit(self, gist_id, format='html'):
-        c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
 
         if c.gist.is_expired:
             log.error('Gist expired at %s',
@@ -205,7 +203,7 b' class GistsController(BaseController):'
             raise HTTPNotFound()
 
         self.__load_defaults(extra_values=('0', _('Unmodified')))
-        rendered = render('admin/gists/edit.html')
+        rendered = base.render('admin/gists/edit.html')
 
         if request.POST:
             rpost = request.POST
@@ -233,16 +231,16 b' class GistsController(BaseController):'
                     lifetime=rpost['lifetime']
                 )
 
-                Session().commit()
-                h.flash(_('Successfully updated gist content'), category='success')
+                meta.Session().commit()
+                webutils.flash(_('Successfully updated gist content'), category='success')
             except NodeNotChangedError:
                 # raised if nothing was changed in repo itself. We anyway then
                 # store only DB stuff for gist
-                Session().commit()
-                h.flash(_('Successfully updated gist data'), category='success')
+                meta.Session().commit()
+                webutils.flash(_('Successfully updated gist data'), category='success')
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of gist %s') % gist_id,
+                webutils.flash(_('Error occurred during update of gist %s') % gist_id,
                         category='error')
 
             raise HTTPFound(location=url('gist', gist_id=gist_id))
@@ -250,9 +248,9 b' class GistsController(BaseController):'
         return rendered
 
     @LoginRequired()
-    @jsonify
+    @base.jsonify
     def check_revision(self, gist_id):
-        c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
         last_rev = c.gist.scm_instance.get_changeset()
         success = True
         revision = request.POST.get('revision')

kallithea/controllers/admin/my_account.py

@@ -35,16 +35,14 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 
-from kallithea.config.routing import url
-from kallithea.lib import auth_modules
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import auth_modules, webutils
 from kallithea.lib.auth import AuthUser, LoginRequired
-from kallithea.lib.base import BaseController, IfSshEnabled, render
 from kallithea.lib.utils2 import generate_api_key, safe_int
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.api_key import ApiKeyModel
-from kallithea.model.db import Repository, User, UserEmailMap, UserFollowing
 from kallithea.model.forms import PasswordChangeForm, UserForm
-from kallithea.model.meta import Session
 from kallithea.model.repo import RepoModel
 from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException
 from kallithea.model.user import UserModel
@@ -53,35 +51,30 b' from kallithea.model.user import UserMod'
 log = logging.getLogger(__name__)
 
 
-class MyAccountController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
-    # To properly map this controller, ensure your config/routing.py
-    # file has a resource setup:
-    #     map.resource('setting', 'settings', controller='admin/settings',
-    #         path_prefix='/admin', name_prefix='admin_')
+class MyAccountController(base.BaseController):
 
     @LoginRequired()
     def _before(self, *args, **kwargs):
         super(MyAccountController, self)._before(*args, **kwargs)
 
     def __load_data(self):
-        c.user = User.get(request.authuser.user_id)
+        c.user = db.User.get(request.authuser.user_id)
         if c.user.is_default_user:
-            h.flash(_("You can't edit this user since it's"
+            webutils.flash(_("You can't edit this user since it's"
                       " crucial for entire application"), category='warning')
             raise HTTPFound(location=url('users'))
 
     def _load_my_repos_data(self, watched=False):
         if watched:
             admin = False
-            repos_list = Session().query(Repository) \
-                         .join(UserFollowing) \
-                         .filter(UserFollowing.user_id ==
+            repos_list = meta.Session().query(db.Repository) \
+                         .join(db.UserFollowing) \
+                         .filter(db.UserFollowing.user_id ==
                                  request.authuser.user_id).all()
         else:
             admin = True
-            repos_list = Session().query(Repository) \
-                         .filter(Repository.owner_id ==
+            repos_list = meta.Session().query(db.Repository) \
+                         .filter(db.Repository.owner_id ==
                                  request.authuser.user_id).all()
 
         return RepoModel().get_repos_as_dict(repos_list, admin=admin)
@@ -91,7 +84,7 b' class MyAccountController(BaseController'
         self.__load_data()
         c.perm_user = AuthUser(user_id=request.authuser.user_id)
         managed_fields = auth_modules.get_managed_fields(c.user)
-        def_user_perms = AuthUser(dbuser=User.get_default_user()).permissions['global']
+        def_user_perms = AuthUser(dbuser=db.User.get_default_user()).global_permissions
         if 'hg.register.none' in def_user_perms:
             managed_fields.extend(['username', 'firstname', 'lastname', 'email'])
 
@@ -116,14 +109,14 b' class MyAccountController(BaseController'
 
                 UserModel().update(request.authuser.user_id, form_result,
                                    skip_attrs=skip_attrs)
-                h.flash(_('Your account was updated successfully'),
+                webutils.flash(_('Your account was updated successfully'),
                         category='success')
-                Session().commit()
+                meta.Session().commit()
                 update = True
 
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('admin/my_account/my_account.html'),
+                    base.render('admin/my_account/my_account.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -131,12 +124,12 b' class MyAccountController(BaseController'
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of user %s')
+                webutils.flash(_('Error occurred during update of user %s')
                         % form_result.get('username'), category='error')
         if update:
             raise HTTPFound(location='my_account')
         return htmlfill.render(
-            render('admin/my_account/my_account.html'),
+            base.render('admin/my_account/my_account.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -153,11 +146,11 b' class MyAccountController(BaseController'
             try:
                 form_result = _form.to_python(request.POST)
                 UserModel().update(request.authuser.user_id, form_result)
-                Session().commit()
-                h.flash(_("Successfully updated password"), category='success')
+                meta.Session().commit()
+                webutils.flash(_("Successfully updated password"), category='success')
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('admin/my_account/my_account.html'),
+                    base.render('admin/my_account/my_account.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -165,9 +158,9 b' class MyAccountController(BaseController'
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of user password'),
+                webutils.flash(_('Error occurred during update of user password'),
                         category='error')
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_repos(self):
         c.active = 'repos'
@@ -175,7 +168,7 b' class MyAccountController(BaseController'
 
         # data used to render the grid
         c.data = self._load_my_repos_data()
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_watched(self):
         c.active = 'watched'
@@ -183,36 +176,36 b' class MyAccountController(BaseController'
 
         # data used to render the grid
         c.data = self._load_my_repos_data(watched=True)
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_perms(self):
         c.active = 'perms'
         self.__load_data()
         c.perm_user = AuthUser(user_id=request.authuser.user_id)
 
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_emails(self):
         c.active = 'emails'
         self.__load_data()
 
-        c.user_email_map = UserEmailMap.query() \
-            .filter(UserEmailMap.user == c.user).all()
-        return render('admin/my_account/my_account.html')
+        c.user_email_map = db.UserEmailMap.query() \
+            .filter(db.UserEmailMap.user == c.user).all()
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_emails_add(self):
         email = request.POST.get('new_email')
 
         try:
             UserModel().add_extra_email(request.authuser.user_id, email)
-            Session().commit()
-            h.flash(_("Added email %s to user") % email, category='success')
+            meta.Session().commit()
+            webutils.flash(_("Added email %s to user") % email, category='success')
         except formencode.Invalid as error:
             msg = error.error_dict['email']
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during email saving'),
+            webutils.flash(_('An error occurred during email saving'),
                     category='error')
         raise HTTPFound(location=url('my_account_emails'))
 
@@ -220,8 +213,8 b' class MyAccountController(BaseController'
         email_id = request.POST.get('del_email_id')
         user_model = UserModel()
         user_model.delete_extra_email(request.authuser.user_id, email_id)
-        Session().commit()
-        h.flash(_("Removed email from user"), category='success')
+        meta.Session().commit()
+        webutils.flash(_("Removed email from user"), category='success')
         raise HTTPFound(location=url('my_account_emails'))
 
     def my_account_api_keys(self):
@@ -238,59 +231,59 b' class MyAccountController(BaseController'
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
         c.user_api_keys = ApiKeyModel().get_api_keys(request.authuser.user_id,
                                                      show_expired=show_expired)
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
     def my_account_api_keys_add(self):
         lifetime = safe_int(request.POST.get('lifetime'), -1)
         description = request.POST.get('description')
         ApiKeyModel().create(request.authuser.user_id, description, lifetime)
-        Session().commit()
-        h.flash(_("API key successfully created"), category='success')
+        meta.Session().commit()
+        webutils.flash(_("API key successfully created"), category='success')
         raise HTTPFound(location=url('my_account_api_keys'))
 
     def my_account_api_keys_delete(self):
         api_key = request.POST.get('del_api_key')
         if request.POST.get('del_api_key_builtin'):
-            user = User.get(request.authuser.user_id)
+            user = db.User.get(request.authuser.user_id)
             user.api_key = generate_api_key()
-            Session().commit()
-            h.flash(_("API key successfully reset"), category='success')
+            meta.Session().commit()
+            webutils.flash(_("API key successfully reset"), category='success')
         elif api_key:
             ApiKeyModel().delete(api_key, request.authuser.user_id)
-            Session().commit()
-            h.flash(_("API key successfully deleted"), category='success')
+            meta.Session().commit()
+            webutils.flash(_("API key successfully deleted"), category='success')
 
         raise HTTPFound(location=url('my_account_api_keys'))
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys(self):
         c.active = 'ssh_keys'
         self.__load_data()
         c.user_ssh_keys = SshKeyModel().get_ssh_keys(request.authuser.user_id)
-        return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys_add(self):
         description = request.POST.get('description')
         public_key = request.POST.get('public_key')
         try:
             new_ssh_key = SshKeyModel().create(request.authuser.user_id,
                                                description, public_key)
-            Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
+            webutils.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('my_account_ssh_keys'))
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys_delete(self):
         fingerprint = request.POST.get('del_public_key_fingerprint')
         try:
             SshKeyModel().delete(fingerprint, request.authuser.user_id)
-            Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key successfully deleted"), category='success')
+            webutils.flash(_("SSH key successfully deleted"), category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('my_account_ssh_keys'))

kallithea/controllers/admin/permissions.py

@@ -36,24 +36,19 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
-from kallithea.model.db import User, UserIpMap
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import DefaultPermissionsForm
-from kallithea.model.meta import Session
 from kallithea.model.permission import PermissionModel
 
 
 log = logging.getLogger(__name__)
 
 
-class PermissionsController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
-    # To properly map this controller, ensure your config/routing.py
-    # file has a resource setup:
-    #     map.resource('permission', 'permissions')
+class PermissionsController(base.BaseController):
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
@@ -61,18 +56,22 b' class PermissionsController(BaseControll'
         super(PermissionsController, self)._before(*args, **kwargs)
 
     def __load_data(self):
+        # Permissions for the Default user on new repositories
         c.repo_perms_choices = [('repository.none', _('None'),),
                                    ('repository.read', _('Read'),),
                                    ('repository.write', _('Write'),),
                                    ('repository.admin', _('Admin'),)]
+        # Permissions for the Default user on new repository groups
         c.group_perms_choices = [('group.none', _('None'),),
                                  ('group.read', _('Read'),),
                                  ('group.write', _('Write'),),
                                  ('group.admin', _('Admin'),)]
+        # Permissions for the Default user on new user groups
         c.user_group_perms_choices = [('usergroup.none', _('None'),),
                                       ('usergroup.read', _('Read'),),
                                       ('usergroup.write', _('Write'),),
                                       ('usergroup.admin', _('Admin'),)]
+        # Registration - allow new Users to create an account
         c.register_choices = [
             ('hg.register.none',
                 _('Disabled')),
@@ -80,26 +79,18 b' class PermissionsController(BaseControll'
                 _('Allowed with manual account activation')),
             ('hg.register.auto_activate',
                 _('Allowed with automatic account activation')), ]
-
+        # External auth account activation
         c.extern_activate_choices = [
             ('hg.extern_activate.manual', _('Manual activation of external account')),
             ('hg.extern_activate.auto', _('Automatic activation of external account')),
         ]
-
+        # Top level repository creation
         c.repo_create_choices = [('hg.create.none', _('Disabled')),
                                  ('hg.create.repository', _('Enabled'))]
-
-        c.repo_create_on_write_choices = [
-            ('hg.create.write_on_repogroup.true', _('Enabled')),
-            ('hg.create.write_on_repogroup.false', _('Disabled')),
-        ]
-
+        # User group creation
         c.user_group_create_choices = [('hg.usergroup.create.false', _('Disabled')),
                                        ('hg.usergroup.create.true', _('Enabled'))]
-
-        c.repo_group_create_choices = [('hg.repogroup.create.false', _('Disabled')),
-                                       ('hg.repogroup.create.true', _('Enabled'))]
-
+        # Repository forking:
         c.fork_choices = [('hg.fork.none', _('Disabled')),
                           ('hg.fork.repository', _('Enabled'))]
 
@@ -112,8 +103,6 b' class PermissionsController(BaseControll'
                 [x[0] for x in c.group_perms_choices],
                 [x[0] for x in c.user_group_perms_choices],
                 [x[0] for x in c.repo_create_choices],
-                [x[0] for x in c.repo_create_on_write_choices],
-                [x[0] for x in c.repo_group_create_choices],
                 [x[0] for x in c.user_group_create_choices],
                 [x[0] for x in c.fork_choices],
                 [x[0] for x in c.register_choices],
@@ -123,15 +112,15 b' class PermissionsController(BaseControll'
                 form_result = _form.to_python(dict(request.POST))
                 form_result.update({'perm_user_name': 'default'})
                 PermissionModel().update(form_result)
-                Session().commit()
-                h.flash(_('Global permissions updated successfully'),
+                meta.Session().commit()
+                webutils.flash(_('Global permissions updated successfully'),
                         category='success')
 
             except formencode.Invalid as errors:
                 defaults = errors.value
 
                 return htmlfill.render(
-                    render('admin/permissions/permissions.html'),
+                    base.render('admin/permissions/permissions.html'),
                     defaults=defaults,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -139,12 +128,12 b' class PermissionsController(BaseControll'
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of permissions'),
+                webutils.flash(_('Error occurred during update of permissions'),
                         category='error')
 
             raise HTTPFound(location=url('admin_permissions'))
 
-        c.user = User.get_default_user()
+        c.user = db.User.get_default_user()
         defaults = {'anonymous': c.user.active}
 
         for p in c.user.user_perms:
@@ -157,15 +146,9 b' class PermissionsController(BaseControll'
             if p.permission.permission_name.startswith('usergroup.'):
                 defaults['default_user_group_perm'] = p.permission.permission_name
 
-            if p.permission.permission_name.startswith('hg.create.write_on_repogroup.'):
-                defaults['create_on_write'] = p.permission.permission_name
-
             elif p.permission.permission_name.startswith('hg.create.'):
                 defaults['default_repo_create'] = p.permission.permission_name
 
-            if p.permission.permission_name.startswith('hg.repogroup.'):
-                defaults['default_repo_group_create'] = p.permission.permission_name
-
             if p.permission.permission_name.startswith('hg.usergroup.'):
                 defaults['default_user_group_create'] = p.permission.permission_name
 
@@ -179,21 +162,21 b' class PermissionsController(BaseControll'
                 defaults['default_fork'] = p.permission.permission_name
 
         return htmlfill.render(
-            render('admin/permissions/permissions.html'),
+            base.render('admin/permissions/permissions.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     def permission_ips(self):
         c.active = 'ips'
-        c.user = User.get_default_user()
-        c.user_ip_map = UserIpMap.query() \
-                        .filter(UserIpMap.user == c.user).all()
+        c.user = db.User.get_default_user()
+        c.user_ip_map = db.UserIpMap.query() \
+                        .filter(db.UserIpMap.user == c.user).all()
 
-        return render('admin/permissions/permissions.html')
+        return base.render('admin/permissions/permissions.html')
 
     def permission_perms(self):
         c.active = 'perms'
-        c.user = User.get_default_user()
+        c.user = db.User.get_default_user()
         c.perm_user = AuthUser(dbuser=c.user)
-        return render('admin/permissions/permissions.html')
+        return base.render('admin/permissions/permissions.html')

kallithea/controllers/admin/repo_groups.py

@@ -36,14 +36,13 b' from tg.i18n import ugettext as _'
 from tg.i18n import ungettext
 from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoGroupPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
 from kallithea.lib.utils2 import safe_int
-from kallithea.model.db import RepoGroup, Repository
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm
-from kallithea.model.meta import Session
 from kallithea.model.repo import RepoModel
 from kallithea.model.repo_group import RepoGroupModel
 from kallithea.model.scm import AvailableRepoGroupChoices, RepoGroupList
@@ -52,7 +51,7 b' from kallithea.model.scm import Availabl'
 log = logging.getLogger(__name__)
 
 
-class RepoGroupsController(BaseController):
+class RepoGroupsController(base.BaseController):
 
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
@@ -63,7 +62,7 b' class RepoGroupsController(BaseControlle'
         exclude is used for not moving group to itself TODO: also exclude descendants
         Note: only admin can create top level groups
         """
-        repo_groups = AvailableRepoGroupChoices([], 'admin', extras)
+        repo_groups = AvailableRepoGroupChoices('admin', extras)
         exclude_group_ids = set(rg.group_id for rg in exclude)
         c.repo_groups = [rg for rg in repo_groups
                          if rg[0] not in exclude_group_ids]
@@ -74,7 +73,7 b' class RepoGroupsController(BaseControlle'
 
         :param group_id:
         """
-        repo_group = RepoGroup.get_or_404(group_id)
+        repo_group = db.RepoGroup.get_or_404(group_id)
         data = repo_group.get_dict()
         data['group_name'] = repo_group.name
 
@@ -98,7 +97,7 b' class RepoGroupsController(BaseControlle'
         return False
 
     def index(self, format='html'):
-        _list = RepoGroup.query(sorted=True).all()
+        _list = db.RepoGroup.query(sorted=True).all()
         group_iter = RepoGroupList(_list, perm_level='admin')
         repo_groups_data = []
         _tmpl_lookup = app_globals.mako_lookup
@@ -106,22 +105,22 b' class RepoGroupsController(BaseControlle'
 
         def repo_group_name(repo_group_name, children_groups):
             return template.get_def("repo_group_name") \
-                .render_unicode(repo_group_name, children_groups, _=_, h=h, c=c)
+                .render_unicode(repo_group_name, children_groups, _=_, webutils=webutils, c=c)
 
         def repo_group_actions(repo_group_id, repo_group_name, gr_count):
             return template.get_def("repo_group_actions") \
-                .render_unicode(repo_group_id, repo_group_name, gr_count, _=_, h=h, c=c,
+                .render_unicode(repo_group_id, repo_group_name, gr_count, _=_, webutils=webutils, c=c,
                         ungettext=ungettext)
 
         for repo_gr in group_iter:
             children_groups = [g.name for g in repo_gr.parents] + [repo_gr.name]
             repo_count = repo_gr.repositories.count()
             repo_groups_data.append({
-                "raw_name": h.escape(repo_gr.group_name),
+                "raw_name": webutils.escape(repo_gr.group_name),
                 "group_name": repo_group_name(repo_gr.group_name, children_groups),
-                "desc": h.escape(repo_gr.group_description),
+                "desc": webutils.escape(repo_gr.group_description),
                 "repos": repo_count,
-                "owner": h.person(repo_gr.owner),
+                "owner": repo_gr.owner.username,
                 "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,
                                              repo_count)
             })
@@ -132,7 +131,7 b' class RepoGroupsController(BaseControlle'
             "records": repo_groups_data
         }
 
-        return render('admin/repo_groups/repo_groups.html')
+        return base.render('admin/repo_groups/repo_groups.html')
 
     def create(self):
         self.__load_defaults()
@@ -150,11 +149,11 b' class RepoGroupsController(BaseControlle'
                 owner=request.authuser.user_id, # TODO: make editable
                 copy_permissions=form_result['group_copy_permissions']
             )
-            Session().commit()
+            meta.Session().commit()
             # TODO: in future action_logger(, '', '', '')
         except formencode.Invalid as errors:
             return htmlfill.render(
-                render('admin/repo_groups/repo_group_add.html'),
+                base.render('admin/repo_groups/repo_group_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -162,14 +161,14 b' class RepoGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during creation of repository group %s')
+            webutils.flash(_('Error occurred during creation of repository group %s')
                     % request.POST.get('group_name'), category='error')
             if form_result is None:
                 raise
             parent_group_id = form_result['parent_group_id']
             # TODO: maybe we should get back to the main view, not the admin one
             raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))
-        h.flash(_('Created repository group %s') % gr.group_name,
+        webutils.flash(_('Created repository group %s') % gr.group_name,
                 category='success')
         raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))
 
@@ -181,7 +180,7 b' class RepoGroupsController(BaseControlle'
         else:
             # we pass in parent group into creation form, thus we know
             # what would be the group, we can check perms here !
-            group = RepoGroup.get(parent_group_id) if parent_group_id else None
+            group = db.RepoGroup.get(parent_group_id) if parent_group_id else None
             group_name = group.group_name if group else None
             if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):
                 pass
@@ -190,7 +189,7 b' class RepoGroupsController(BaseControlle'
 
         self.__load_defaults()
         return htmlfill.render(
-            render('admin/repo_groups/repo_group_add.html'),
+            base.render('admin/repo_groups/repo_group_add.html'),
             defaults={'parent_group_id': parent_group_id},
             errors={},
             prefix_error=False,
@@ -199,7 +198,7 b' class RepoGroupsController(BaseControlle'
 
     @HasRepoGroupPermissionLevelDecorator('admin')
     def update(self, group_name):
-        c.repo_group = RepoGroup.guess_instance(group_name)
+        c.repo_group = db.RepoGroup.guess_instance(group_name)
         self.__load_defaults(extras=[c.repo_group.parent_group],
                              exclude=[c.repo_group])
 
@@ -221,8 +220,8 b' class RepoGroupsController(BaseControlle'
             form_result = repo_group_form.to_python(dict(request.POST))
 
             new_gr = RepoGroupModel().update(group_name, form_result)
-            Session().commit()
-            h.flash(_('Updated repository group %s')
+            meta.Session().commit()
+            webutils.flash(_('Updated repository group %s')
                     % form_result['group_name'], category='success')
             # we now have new name !
             group_name = new_gr.group_name
@@ -230,7 +229,7 b' class RepoGroupsController(BaseControlle'
         except formencode.Invalid as errors:
             c.active = 'settings'
             return htmlfill.render(
-                render('admin/repo_groups/repo_group_edit.html'),
+                base.render('admin/repo_groups/repo_group_edit.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -238,35 +237,35 b' class RepoGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of repository group %s')
+            webutils.flash(_('Error occurred during update of repository group %s')
                     % request.POST.get('group_name'), category='error')
 
         raise HTTPFound(location=url('edit_repo_group', group_name=group_name))
 
     @HasRepoGroupPermissionLevelDecorator('admin')
     def delete(self, group_name):
-        gr = c.repo_group = RepoGroup.guess_instance(group_name)
+        gr = c.repo_group = db.RepoGroup.guess_instance(group_name)
         repos = gr.repositories.all()
         if repos:
-            h.flash(_('This group contains %s repositories and cannot be '
+            webutils.flash(_('This group contains %s repositories and cannot be '
                       'deleted') % len(repos), category='warning')
             raise HTTPFound(location=url('repos_groups'))
 
         children = gr.children.all()
         if children:
-            h.flash(_('This group contains %s subgroups and cannot be deleted'
+            webutils.flash(_('This group contains %s subgroups and cannot be deleted'
                       % (len(children))), category='warning')
             raise HTTPFound(location=url('repos_groups'))
 
         try:
             RepoGroupModel().delete(group_name)
-            Session().commit()
-            h.flash(_('Removed repository group %s') % group_name,
+            meta.Session().commit()
+            webutils.flash(_('Removed repository group %s') % group_name,
                     category='success')
             # TODO: in future action_logger(, '', '', '')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during deletion of repository group %s')
+            webutils.flash(_('Error occurred during deletion of repository group %s')
                     % group_name, category='error')
 
         if gr.parent_group:
@@ -279,7 +278,7 b' class RepoGroupsController(BaseControlle'
         the group by id view instead
         """
         group_name = group_name.rstrip('/')
-        id_ = RepoGroup.get_by_group_name(group_name)
+        id_ = db.RepoGroup.get_by_group_name(group_name)
         if id_:
             return self.show(group_name)
         raise HTTPNotFound
@@ -288,29 +287,29 b' class RepoGroupsController(BaseControlle'
     def show(self, group_name):
         c.active = 'settings'
 
-        c.group = c.repo_group = RepoGroup.guess_instance(group_name)
+        c.group = c.repo_group = db.RepoGroup.guess_instance(group_name)
 
-        groups = RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()
+        groups = db.RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()
         repo_groups_list = self.scm_model.get_repo_groups(groups)
 
-        repos_list = Repository.query(sorted=True).filter_by(group=c.group).all()
+        repos_list = db.Repository.query(sorted=True).filter_by(group=c.group).all()
         c.data = RepoModel().get_repos_as_dict(repos_list,
                                                repo_groups_list=repo_groups_list,
                                                short_name=True)
 
-        return render('admin/repo_groups/repo_group_show.html')
+        return base.render('admin/repo_groups/repo_group_show.html')
 
     @HasRepoGroupPermissionLevelDecorator('admin')
     def edit(self, group_name):
         c.active = 'settings'
 
-        c.repo_group = RepoGroup.guess_instance(group_name)
+        c.repo_group = db.RepoGroup.guess_instance(group_name)
         self.__load_defaults(extras=[c.repo_group.parent_group],
                              exclude=[c.repo_group])
         defaults = self.__load_data(c.repo_group.group_id)
 
         return htmlfill.render(
-            render('admin/repo_groups/repo_group_edit.html'),
+            base.render('admin/repo_groups/repo_group_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -319,19 +318,19 b' class RepoGroupsController(BaseControlle'
     @HasRepoGroupPermissionLevelDecorator('admin')
     def edit_repo_group_advanced(self, group_name):
         c.active = 'advanced'
-        c.repo_group = RepoGroup.guess_instance(group_name)
+        c.repo_group = db.RepoGroup.guess_instance(group_name)
 
-        return render('admin/repo_groups/repo_group_edit.html')
+        return base.render('admin/repo_groups/repo_group_edit.html')
 
     @HasRepoGroupPermissionLevelDecorator('admin')
     def edit_repo_group_perms(self, group_name):
         c.active = 'perms'
-        c.repo_group = RepoGroup.guess_instance(group_name)
+        c.repo_group = db.RepoGroup.guess_instance(group_name)
         self.__load_defaults()
         defaults = self.__load_data(c.repo_group.group_id)
 
         return htmlfill.render(
-            render('admin/repo_groups/repo_group_edit.html'),
+            base.render('admin/repo_groups/repo_group_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -345,13 +344,13 b' class RepoGroupsController(BaseControlle'
         :param group_name:
         """
 
-        c.repo_group = RepoGroup.guess_instance(group_name)
+        c.repo_group = db.RepoGroup.guess_instance(group_name)
         valid_recursive_choices = ['none', 'repos', 'groups', 'all']
         form_result = RepoGroupPermsForm(valid_recursive_choices)().to_python(request.POST)
         if not request.authuser.is_admin:
             if self._revoke_perms_on_yourself(form_result):
                 msg = _('Cannot revoke permission for yourself as admin')
-                h.flash(msg, category='warning')
+                webutils.flash(msg, category='warning')
                 raise HTTPFound(location=url('edit_repo_group_perms', group_name=group_name))
         recursive = form_result['recursive']
         # iterate over all members(if in recursive mode) of this groups and
@@ -364,8 +363,8 b' class RepoGroupsController(BaseControlle'
         # TODO: implement this
         #action_logger(request.authuser, 'admin_changed_repo_permissions',
         #              repo_name, request.ip_addr)
-        Session().commit()
-        h.flash(_('Repository group permissions updated'), category='success')
+        meta.Session().commit()
+        webutils.flash(_('Repository group permissions updated'), category='success')
         raise HTTPFound(location=url('edit_repo_group_perms', group_name=group_name))
 
     @HasRepoGroupPermissionLevelDecorator('admin')
@@ -381,7 +380,7 b' class RepoGroupsController(BaseControlle'
             if not request.authuser.is_admin:
                 if obj_type == 'user' and request.authuser.user_id == obj_id:
                     msg = _('Cannot revoke permission for yourself as admin')
-                    h.flash(msg, category='warning')
+                    webutils.flash(msg, category='warning')
                     raise Exception('revoke admin permission on self')
             recursive = request.POST.get('recursive', 'none')
             if obj_type == 'user':
@@ -394,9 +393,9 b' class RepoGroupsController(BaseControlle'
                                                    obj_type='user_group',
                                                    recursive=recursive)
 
-            Session().commit()
+            meta.Session().commit()
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during revoking of permission'),
+            webutils.flash(_('An error occurred during revoking of permission'),
                     category='error')
             raise HTTPInternalServerError()

kallithea/controllers/admin/repos.py

@@ -28,7 +28,6 b' Original author and date, and relevant c'
 import logging
 import traceback
 
-import celery.result
 import formencode
 from formencode import htmlfill
 from tg import request
@@ -37,17 +36,15 b' from tg.i18n import ugettext as _'
 from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound
 
 import kallithea
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
-from kallithea.lib.auth import HasPermissionAny, HasRepoPermissionLevelDecorator, LoginRequired, NotAnonymous
-from kallithea.lib.base import BaseRepoController, jsonify, render
+from kallithea.controllers import base
+from kallithea.lib import webutils
+from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired, NotAnonymous
 from kallithea.lib.exceptions import AttachedForksError
-from kallithea.lib.utils import action_logger
 from kallithea.lib.utils2 import safe_int
 from kallithea.lib.vcs import RepositoryError
-from kallithea.model.db import RepoGroup, Repository, RepositoryField, Setting, UserFollowing
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta, userlog
 from kallithea.model.forms import RepoFieldForm, RepoForm, RepoPermsForm
-from kallithea.model.meta import Session
 from kallithea.model.repo import RepoModel
 from kallithea.model.scm import AvailableRepoGroupChoices, RepoList, ScmModel
 
@@ -55,12 +52,7 b' from kallithea.model.scm import Availabl'
 log = logging.getLogger(__name__)
 
 
-class ReposController(BaseRepoController):
-    """
-    REST Controller styled on the Atom Publishing Protocol"""
-    # To properly map this controller, ensure your config/routing.py
-    # file has a resource setup:
-    #     map.resource('repo', 'repos')
+class ReposController(base.BaseRepoController):
 
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
@@ -70,20 +62,14 b' class ReposController(BaseRepoController'
         repo_obj = c.db_repo
 
         if repo_obj is None:
-            h.not_mapped_error(c.repo_name)
-            raise HTTPFound(location=url('repos'))
+            raise HTTPNotFound()
 
         return repo_obj
 
     def __load_defaults(self, repo=None):
-        top_perms = ['hg.create.repository']
-        if HasPermissionAny('hg.create.write_on_repogroup.true')():
-            repo_group_perm_level = 'write'
-        else:
-            repo_group_perm_level = 'admin'
         extras = [] if repo is None else [repo.group]
 
-        c.repo_groups = AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras)
+        c.repo_groups = AvailableRepoGroupChoices('write', extras)
 
         c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo)
 
@@ -101,13 +87,13 b' class ReposController(BaseRepoController'
         return defaults
 
     def index(self, format='html'):
-        repos_list = RepoList(Repository.query(sorted=True).all(), perm_level='admin')
+        repos_list = RepoList(db.Repository.query(sorted=True).all(), perm_level='admin')
         # the repo list will be filtered to only show repos where the user has read permissions
         repos_data = RepoModel().get_repos_as_dict(repos_list, admin=True)
         # data used to render the grid
         c.data = repos_data
 
-        return render('admin/repos/repos.html')
+        return base.render('admin/repos/repos.html')
 
     @NotAnonymous()
     def create(self):
@@ -120,7 +106,7 b' class ReposController(BaseRepoController'
         except formencode.Invalid as errors:
             log.info(errors)
             return htmlfill.render(
-                render('admin/repos/repo_add.html'),
+                base.render('admin/repos/repo_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -130,18 +116,17 b' class ReposController(BaseRepoController'
         try:
             # create is done sometimes async on celery, db transaction
             # management is handled there.
-            task = RepoModel().create(form_result, request.authuser.user_id)
-            task_id = task.task_id
+            RepoModel().create(form_result, request.authuser.user_id)
         except Exception:
             log.error(traceback.format_exc())
             msg = (_('Error creating repository %s')
                    % form_result.get('repo_name'))
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPFound(location=url('home'))
 
-        raise HTTPFound(location=h.url('repo_creating_home',
+        raise HTTPFound(location=webutils.url('repo_creating_home',
                               repo_name=form_result['repo_name_full'],
-                              task_id=task_id))
+                              ))
 
     @NotAnonymous()
     def create_repository(self):
@@ -151,9 +136,9 b' class ReposController(BaseRepoController'
         parent_group = request.GET.get('parent_group')
 
         ## apply the defaults from defaults page
-        defaults = Setting.get_default_repo_settings(strip_prefix=True)
+        defaults = db.Setting.get_default_repo_settings(strip_prefix=True)
         if parent_group:
-            prg = RepoGroup.get(parent_group)
+            prg = db.RepoGroup.get(parent_group)
             if prg is None or not any(rgc[0] == prg.group_id
                                       for rgc in c.repo_groups):
                 raise HTTPForbidden
@@ -162,7 +147,7 b' class ReposController(BaseRepoController'
         defaults.update({'repo_group': parent_group})
 
         return htmlfill.render(
-            render('admin/repos/repo_add.html'),
+            base.render('admin/repos/repo_add.html'),
             defaults=defaults,
             errors={},
             prefix_error=False,
@@ -172,39 +157,30 b' class ReposController(BaseRepoController'
     @LoginRequired()
     def repo_creating(self, repo_name):
         c.repo = repo_name
-        c.task_id = request.GET.get('task_id')
         if not c.repo:
             raise HTTPNotFound()
-        return render('admin/repos/repo_creating.html')
+        return base.render('admin/repos/repo_creating.html')
 
     @LoginRequired()
-    @jsonify
+    @base.jsonify
     def repo_check(self, repo_name):
         c.repo = repo_name
-        task_id = request.GET.get('task_id')
-
-        if task_id and task_id not in ['None']:
-            if kallithea.CELERY_APP:
-                task_result = celery.result.AsyncResult(task_id, app=kallithea.CELERY_APP)
-                if task_result.failed():
-                    raise HTTPInternalServerError(task_result.traceback)
-
-        repo = Repository.get_by_repo_name(repo_name)
-        if repo and repo.repo_state == Repository.STATE_CREATED:
+        repo = db.Repository.get_by_repo_name(repo_name)
+        if repo and repo.repo_state == db.Repository.STATE_CREATED:
             if repo.clone_uri:
-                h.flash(_('Created repository %s from %s')
+                webutils.flash(_('Created repository %s from %s')
                         % (repo.repo_name, repo.clone_uri_hidden), category='success')
             else:
-                repo_url = h.link_to(repo.repo_name,
-                                     h.url('summary_home',
+                repo_url = webutils.link_to(repo.repo_name,
+                                     webutils.url('summary_home',
                                            repo_name=repo.repo_name))
                 fork = repo.fork
                 if fork is not None:
                     fork_name = fork.repo_name
-                    h.flash(h.HTML(_('Forked repository %s as %s'))
+                    webutils.flash(webutils.HTML(_('Forked repository %s as %s'))
                             % (fork_name, repo_url), category='success')
                 else:
-                    h.flash(h.HTML(_('Created repository %s')) % repo_url,
+                    webutils.flash(webutils.HTML(_('Created repository %s')) % repo_url,
                             category='success')
             return {'result': True}
         return {'result': False}
@@ -214,12 +190,12 b' class ReposController(BaseRepoController'
         c.repo_info = self._load_repo()
         self.__load_defaults(c.repo_info)
         c.active = 'settings'
-        c.repo_fields = RepositoryField.query() \
-            .filter(RepositoryField.repository == c.repo_info).all()
+        c.repo_fields = db.RepositoryField.query() \
+            .filter(db.RepositoryField.repository == c.repo_info).all()
 
         repo_model = RepoModel()
         changed_name = repo_name
-        repo = Repository.get_by_repo_name(repo_name)
+        repo = db.Repository.get_by_repo_name(repo_name)
         old_data = {
             'repo_name': repo_name,
             'repo_group': repo.group.get_dict() if repo.group else {},
@@ -233,18 +209,18 b' class ReposController(BaseRepoController'
             form_result = _form.to_python(dict(request.POST))
             repo = repo_model.update(repo_name, **form_result)
             ScmModel().mark_for_invalidation(repo_name)
-            h.flash(_('Repository %s updated successfully') % repo_name,
+            webutils.flash(_('Repository %s updated successfully') % repo_name,
                     category='success')
             changed_name = repo.repo_name
-            action_logger(request.authuser, 'admin_updated_repo',
+            userlog.action_logger(request.authuser, 'admin_updated_repo',
                 changed_name, request.ip_addr)
-            Session().commit()
+            meta.Session().commit()
         except formencode.Invalid as errors:
             log.info(errors)
             defaults = self.__load_data()
             defaults.update(errors.value)
             return htmlfill.render(
-                render('admin/repos/repo_edit.html'),
+                base.render('admin/repos/repo_edit.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -253,7 +229,7 b' class ReposController(BaseRepoController'
 
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of repository %s')
+            webutils.flash(_('Error occurred during update of repository %s')
                     % repo_name, category='error')
         raise HTTPFound(location=url('edit_repo', repo_name=changed_name))
 
@@ -262,8 +238,7 b' class ReposController(BaseRepoController'
         repo_model = RepoModel()
         repo = repo_model.get_by_repo_name(repo_name)
         if not repo:
-            h.not_mapped_error(repo_name)
-            raise HTTPFound(location=url('repos'))
+            raise HTTPNotFound()
         try:
             _forks = repo.forks.count()
             handle_forks = None
@@ -271,23 +246,23 b' class ReposController(BaseRepoController'
                 do = request.POST['forks']
                 if do == 'detach_forks':
                     handle_forks = 'detach'
-                    h.flash(_('Detached %s forks') % _forks, category='success')
+                    webutils.flash(_('Detached %s forks') % _forks, category='success')
                 elif do == 'delete_forks':
                     handle_forks = 'delete'
-                    h.flash(_('Deleted %s forks') % _forks, category='success')
+                    webutils.flash(_('Deleted %s forks') % _forks, category='success')
             repo_model.delete(repo, forks=handle_forks)
-            action_logger(request.authuser, 'admin_deleted_repo',
+            userlog.action_logger(request.authuser, 'admin_deleted_repo',
                 repo_name, request.ip_addr)
             ScmModel().mark_for_invalidation(repo_name)
-            h.flash(_('Deleted repository %s') % repo_name, category='success')
-            Session().commit()
+            webutils.flash(_('Deleted repository %s') % repo_name, category='success')
+            meta.Session().commit()
         except AttachedForksError:
-            h.flash(_('Cannot delete repository %s which still has forks')
+            webutils.flash(_('Cannot delete repository %s which still has forks')
                         % repo_name, category='warning')
 
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during deletion of %s') % repo_name,
+            webutils.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         if repo.group:
@@ -297,11 +272,11 b' class ReposController(BaseRepoController'
     @HasRepoPermissionLevelDecorator('admin')
     def edit(self, repo_name):
         defaults = self.__load_data()
-        c.repo_fields = RepositoryField.query() \
-            .filter(RepositoryField.repository == c.repo_info).all()
+        c.repo_fields = db.RepositoryField.query() \
+            .filter(db.RepositoryField.repository == c.repo_info).all()
         c.active = 'settings'
         return htmlfill.render(
-            render('admin/repos/repo_edit.html'),
+            base.render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -313,7 +288,7 b' class ReposController(BaseRepoController'
         defaults = RepoModel()._get_defaults(repo_name)
 
         return htmlfill.render(
-            render('admin/repos/repo_edit.html'),
+            base.render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -326,8 +301,8 b' class ReposController(BaseRepoController'
         # TODO: implement this
         #action_logger(request.authuser, 'admin_changed_repo_permissions',
         #              repo_name, request.ip_addr)
-        Session().commit()
-        h.flash(_('Repository permissions updated'), category='success')
+        meta.Session().commit()
+        webutils.flash(_('Repository permissions updated'), category='success')
         raise HTTPFound(location=url('edit_repo_perms', repo_name=repo_name))
 
     @HasRepoPermissionLevelDecorator('admin')
@@ -353,10 +328,10 b' class ReposController(BaseRepoController'
             # TODO: implement this
             #action_logger(request.authuser, 'admin_revoked_repo_permissions',
             #              repo_name, request.ip_addr)
-            Session().commit()
+            meta.Session().commit()
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during revoking of permission'),
+            webutils.flash(_('An error occurred during revoking of permission'),
                     category='error')
             raise HTTPInternalServerError()
         return []
@@ -364,55 +339,55 b' class ReposController(BaseRepoController'
     @HasRepoPermissionLevelDecorator('admin')
     def edit_fields(self, repo_name):
         c.repo_info = self._load_repo()
-        c.repo_fields = RepositoryField.query() \
-            .filter(RepositoryField.repository == c.repo_info).all()
+        c.repo_fields = db.RepositoryField.query() \
+            .filter(db.RepositoryField.repository == c.repo_info).all()
         c.active = 'fields'
         if request.POST:
 
             raise HTTPFound(location=url('repo_edit_fields'))
-        return render('admin/repos/repo_edit.html')
+        return base.render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionLevelDecorator('admin')
     def create_repo_field(self, repo_name):
         try:
             form_result = RepoFieldForm()().to_python(dict(request.POST))
-            new_field = RepositoryField()
-            new_field.repository = Repository.get_by_repo_name(repo_name)
+            new_field = db.RepositoryField()
+            new_field.repository = db.Repository.get_by_repo_name(repo_name)
             new_field.field_key = form_result['new_field_key']
             new_field.field_type = form_result['new_field_type']  # python type
             new_field.field_value = form_result['new_field_value']  # set initial blank value
             new_field.field_desc = form_result['new_field_desc']
             new_field.field_label = form_result['new_field_label']
-            Session().add(new_field)
-            Session().commit()
+            meta.Session().add(new_field)
+            meta.Session().commit()
         except formencode.Invalid as e:
-            h.flash(_('Field validation error: %s') % e.msg, category='error')
+            webutils.flash(_('Field validation error: %s') % e.msg, category='error')
         except Exception as e:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during creation of field: %r') % e, category='error')
+            webutils.flash(_('An error occurred during creation of field: %r') % e, category='error')
         raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionLevelDecorator('admin')
     def delete_repo_field(self, repo_name, field_id):
-        field = RepositoryField.get_or_404(field_id)
+        field = db.RepositoryField.get_or_404(field_id)
         try:
-            Session().delete(field)
-            Session().commit()
+            meta.Session().delete(field)
+            meta.Session().commit()
         except Exception as e:
             log.error(traceback.format_exc())
             msg = _('An error occurred during removal of field')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
         raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionLevelDecorator('admin')
     def edit_advanced(self, repo_name):
         c.repo_info = self._load_repo()
         c.default_user_id = kallithea.DEFAULT_USER_ID
-        c.in_public_journal = UserFollowing.query() \
-            .filter(UserFollowing.user_id == c.default_user_id) \
-            .filter(UserFollowing.follows_repository == c.repo_info).scalar()
+        c.in_public_journal = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == c.default_user_id) \
+            .filter(db.UserFollowing.follows_repository == c.repo_info).scalar()
 
-        _repos = Repository.query(sorted=True).all()
+        _repos = db.Repository.query(sorted=True).all()
         read_access_repos = RepoList(_repos, perm_level='read')
         c.repos_list = [(None, _('-- Not a fork --'))]
         c.repos_list += [(x.repo_id, x.repo_name)
@@ -428,7 +403,7 b' class ReposController(BaseRepoController'
         if request.POST:
             raise HTTPFound(location=url('repo_edit_advanced'))
         return htmlfill.render(
-            render('admin/repos/repo_edit.html'),
+            base.render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -443,14 +418,14 b' class ReposController(BaseRepoController'
         """
 
         try:
-            repo_id = Repository.get_by_repo_name(repo_name).repo_id
+            repo_id = db.Repository.get_by_repo_name(repo_name).repo_id
             user_id = kallithea.DEFAULT_USER_ID
             self.scm_model.toggle_following_repo(repo_id, user_id)
-            h.flash(_('Updated repository visibility in public journal'),
+            webutils.flash(_('Updated repository visibility in public journal'),
                     category='success')
-            Session().commit()
+            meta.Session().commit()
         except Exception:
-            h.flash(_('An error occurred during setting this'
+            webutils.flash(_('An error occurred during setting this'
                       ' repository in public journal'),
                     category='error')
         raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))
@@ -467,15 +442,15 b' class ReposController(BaseRepoController'
             repo = ScmModel().mark_as_fork(repo_name, fork_id,
                                            request.authuser.username)
             fork = repo.fork.repo_name if repo.fork else _('Nothing')
-            Session().commit()
-            h.flash(_('Marked repository %s as fork of %s') % (repo_name, fork),
+            meta.Session().commit()
+            webutils.flash(_('Marked repository %s as fork of %s') % (repo_name, fork),
                     category='success')
         except RepositoryError as e:
             log.error(traceback.format_exc())
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
         except Exception as e:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during this operation'),
+            webutils.flash(_('An error occurred during this operation'),
                     category='error')
 
         raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))
@@ -487,13 +462,13 b' class ReposController(BaseRepoController'
         if request.POST:
             try:
                 ScmModel().pull_changes(repo_name, request.authuser.username, request.ip_addr)
-                h.flash(_('Pulled from remote location'), category='success')
+                webutils.flash(_('Pulled from remote location'), category='success')
             except Exception as e:
                 log.error(traceback.format_exc())
-                h.flash(_('An error occurred during pull from remote location'),
+                webutils.flash(_('An error occurred during pull from remote location'),
                         category='error')
             raise HTTPFound(location=url('edit_repo_remote', repo_name=c.repo_name))
-        return render('admin/repos/repo_edit.html')
+        return base.render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionLevelDecorator('admin')
     def edit_statistics(self, repo_name):
@@ -518,11 +493,11 b' class ReposController(BaseRepoController'
         if request.POST:
             try:
                 RepoModel().delete_stats(repo_name)
-                Session().commit()
+                meta.Session().commit()
             except Exception as e:
                 log.error(traceback.format_exc())
-                h.flash(_('An error occurred during deletion of repository stats'),
+                webutils.flash(_('An error occurred during deletion of repository stats'),
                         category='error')
             raise HTTPFound(location=url('edit_repo_statistics', repo_name=c.repo_name))
 
-        return render('admin/repos/repo_edit.html')
+        return base.render('admin/repos/repo_edit.html')

kallithea/controllers/admin/settings.py

@@ -35,18 +35,17 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+import kallithea
+import kallithea.lib.indexers.daemon
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
-from kallithea.lib.celerylib import tasks
-from kallithea.lib.exceptions import HgsubversionImportError
 from kallithea.lib.utils import repo2db_mapper, set_app_settings
 from kallithea.lib.utils2 import safe_str
 from kallithea.lib.vcs import VCSError
-from kallithea.model.db import Repository, Setting, Ui
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta, notification
 from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm
-from kallithea.model.meta import Session
 from kallithea.model.notification import EmailNotificationModel
 from kallithea.model.scm import ScmModel
 
@@ -54,19 +53,14 b' from kallithea.model.scm import ScmModel'
 log = logging.getLogger(__name__)
 
 
-class SettingsController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
-    # To properly map this controller, ensure your config/routing.py
-    # file has a resource setup:
-    #     map.resource('setting', 'settings', controller='admin/settings',
-    #         path_prefix='/admin', name_prefix='admin_')
+class SettingsController(base.BaseController):
 
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
         super(SettingsController, self)._before(*args, **kwargs)
 
     def _get_hg_ui_settings(self):
-        ret = Ui.query().all()
+        ret = db.Ui.query().all()
 
         settings = {}
         for each in ret:
@@ -92,7 +86,7 b' class SettingsController(BaseController)'
                 form_result = application_form.to_python(dict(request.POST))
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                     render('admin/settings/settings.html'),
+                     base.render('admin/settings/settings.html'),
                      defaults=errors.value,
                      errors=errors.error_dict or {},
                      prefix_error=False,
@@ -101,52 +95,37 b' class SettingsController(BaseController)'
 
             try:
                 if c.visual.allow_repo_location_change:
-                    sett = Ui.get_by_key('paths', '/')
+                    sett = db.Ui.get_by_key('paths', '/')
                     sett.ui_value = form_result['paths_root_path']
 
                 # HOOKS
-                sett = Ui.get_by_key('hooks', Ui.HOOK_UPDATE)
-                sett.ui_active = form_result['hooks_changegroup_update']
+                sett = db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE)
+                sett.ui_active = form_result['hooks_changegroup_kallithea_update']
 
-                sett = Ui.get_by_key('hooks', Ui.HOOK_REPO_SIZE)
-                sett.ui_active = form_result['hooks_changegroup_repo_size']
+                sett = db.Ui.get_by_key('hooks', db.Ui.HOOK_REPO_SIZE)
+                sett.ui_active = form_result['hooks_changegroup_kallithea_repo_size']
 
                 ## EXTENSIONS
-                sett = Ui.get_or_create('extensions', 'largefiles')
+                sett = db.Ui.get_or_create('extensions', 'largefiles')
                 sett.ui_active = form_result['extensions_largefiles']
 
-                sett = Ui.get_or_create('extensions', 'hgsubversion')
-                sett.ui_active = form_result['extensions_hgsubversion']
-                if sett.ui_active:
-                    try:
-                        import hgsubversion  # pragma: no cover
-                        assert hgsubversion
-                    except ImportError:
-                        raise HgsubversionImportError
-
-#                sett = Ui.get_or_create('extensions', 'hggit')
+#                sett = db.Ui.get_or_create('extensions', 'hggit')
 #                sett.ui_active = form_result['extensions_hggit']
 
-                Session().commit()
-
-                h.flash(_('Updated VCS settings'), category='success')
+                meta.Session().commit()
 
-            except HgsubversionImportError:
-                log.error(traceback.format_exc())
-                h.flash(_('Unable to activate hgsubversion support. '
-                          'The "hgsubversion" library is missing'),
-                        category='error')
+                webutils.flash(_('Updated VCS settings'), category='success')
 
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred while updating '
+                webutils.flash(_('Error occurred while updating '
                           'application settings'), category='error')
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -168,33 +147,33 b' class SettingsController(BaseController)'
                                             install_git_hooks=install_git_hooks,
                                             user=request.authuser.username,
                                             overwrite_git_hooks=overwrite_git_hooks)
-            added_msg = h.HTML(', ').join(
-                h.link_to(safe_str(repo_name), h.url('summary_home', repo_name=repo_name)) for repo_name in added
+            added_msg = webutils.HTML(', ').join(
+                webutils.link_to(safe_str(repo_name), webutils.url('summary_home', repo_name=repo_name)) for repo_name in added
             ) or '-'
-            removed_msg = h.HTML(', ').join(
+            removed_msg = webutils.HTML(', ').join(
                 safe_str(repo_name) for repo_name in removed
             ) or '-'
-            h.flash(h.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %
+            webutils.flash(webutils.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %
                     (added_msg, removed_msg), category='success')
 
             if invalidate_cache:
                 log.debug('invalidating all repositories cache')
                 i = 0
-                for repo in Repository.query():
+                for repo in db.Repository.query():
                     try:
                         ScmModel().mark_for_invalidation(repo.repo_name)
                         i += 1
                     except VCSError as e:
                         log.warning('VCS error invalidating %s: %s', repo.repo_name, e)
-                h.flash(_('Invalidated %s repositories') % i, category='success')
+                webutils.flash(_('Invalidated %s repositories') % i, category='success')
 
             raise HTTPFound(location=url('admin_settings_mapping'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -208,7 +187,7 b' class SettingsController(BaseController)'
                 form_result = application_form.to_python(dict(request.POST))
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('admin/settings/settings.html'),
+                    base.render('admin/settings/settings.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -223,25 +202,25 b' class SettingsController(BaseController)'
                     'captcha_public_key',
                     'captcha_private_key',
                 ):
-                    Setting.create_or_update(setting, form_result[setting])
+                    db.Setting.create_or_update(setting, form_result[setting])
 
-                Session().commit()
+                meta.Session().commit()
                 set_app_settings(config)
-                h.flash(_('Updated application settings'), category='success')
+                webutils.flash(_('Updated application settings'), category='success')
 
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred while updating '
+                webutils.flash(_('Error occurred while updating '
                           'application settings'),
                           category='error')
 
             raise HTTPFound(location=url('admin_settings_global'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -255,7 +234,7 b' class SettingsController(BaseController)'
                 form_result = application_form.to_python(dict(request.POST))
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('admin/settings/settings.html'),
+                    base.render('admin/settings/settings.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -277,26 +256,26 b' class SettingsController(BaseController)'
                     ('clone_ssh_tmpl', 'clone_ssh_tmpl', 'unicode'),
                 ]
                 for setting, form_key, type_ in settings:
-                    Setting.create_or_update(setting, form_result[form_key], type_)
+                    db.Setting.create_or_update(setting, form_result[form_key], type_)
 
-                Session().commit()
+                meta.Session().commit()
                 set_app_settings(config)
-                h.flash(_('Updated visualisation settings'),
+                webutils.flash(_('Updated visualisation settings'),
                         category='success')
 
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during updating '
+                webutils.flash(_('Error occurred during updating '
                           'visualisation settings'),
                         category='error')
 
             raise HTTPFound(location=url('admin_settings_visual'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -310,7 +289,7 b' class SettingsController(BaseController)'
             test_body = ('Kallithea Email test, '
                                'Kallithea version: %s' % c.kallithea_version)
             if not test_email:
-                h.flash(_('Please enter email address'), category='error')
+                webutils.flash(_('Please enter email address'), category='error')
                 raise HTTPFound(location=url('admin_settings_email'))
 
             test_email_txt_body = EmailNotificationModel() \
@@ -322,20 +301,19 b' class SettingsController(BaseController)'
 
             recipients = [test_email] if test_email else None
 
-            tasks.send_email(recipients, test_email_subj,
+            notification.send_email(recipients, test_email_subj,
                              test_email_txt_body, test_email_html_body)
 
-            h.flash(_('Send email task created'), category='success')
+            webutils.flash(_('Send email task created'), category='success')
             raise HTTPFound(location=url('admin_settings_email'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
-        import kallithea
         c.ini = kallithea.CONFIG
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -352,16 +330,16 b' class SettingsController(BaseController)'
 
                 try:
                     ui_key = ui_key and ui_key.strip()
-                    if ui_key in (x.ui_key for x in Ui.get_custom_hooks()):
-                        h.flash(_('Hook already exists'), category='error')
-                    elif ui_key in (x.ui_key for x in Ui.get_builtin_hooks()):
-                        h.flash(_('Builtin hooks are read-only. Please use another hook name.'), category='error')
+                    if ui_key in (x.ui_key for x in db.Ui.get_custom_hooks()):
+                        webutils.flash(_('Hook already exists'), category='error')
+                    elif ui_key and '.kallithea_' in ui_key:
+                        webutils.flash(_('Hook names with ".kallithea_" are reserved for internal use. Please use another hook name.'), category='error')
                     elif ui_value and ui_key:
-                        Ui.create_or_update_hook(ui_key, ui_value)
-                        h.flash(_('Added new hook'), category='success')
+                        db.Ui.create_or_update_hook(ui_key, ui_value)
+                        webutils.flash(_('Added new hook'), category='success')
                     elif hook_id:
-                        Ui.delete(hook_id)
-                        Session().commit()
+                        db.Ui.delete(hook_id)
+                        meta.Session().commit()
 
                     # check for edits
                     update = False
@@ -370,27 +348,26 b' class SettingsController(BaseController)'
                                         _d.get('hook_ui_value_new', []),
                                         _d.get('hook_ui_value', [])):
                         if v != ov:
-                            Ui.create_or_update_hook(k, v)
+                            db.Ui.create_or_update_hook(k, v)
                             update = True
 
                     if update:
-                        h.flash(_('Updated hooks'), category='success')
-                    Session().commit()
+                        webutils.flash(_('Updated hooks'), category='success')
+                    meta.Session().commit()
                 except Exception:
                     log.error(traceback.format_exc())
-                    h.flash(_('Error occurred during hook creation'),
+                    webutils.flash(_('Error occurred during hook creation'),
                             category='error')
 
                 raise HTTPFound(location=url('admin_settings_hooks'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
-        c.hooks = Ui.get_builtin_hooks()
-        c.custom_hooks = Ui.get_custom_hooks()
+        c.custom_hooks = db.Ui.get_custom_hooks()
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -401,15 +378,15 b' class SettingsController(BaseController)'
         if request.POST:
             repo_location = self._get_hg_ui_settings()['paths_root_path']
             full_index = request.POST.get('full_index', False)
-            tasks.whoosh_index(repo_location, full_index)
-            h.flash(_('Whoosh reindex task scheduled'), category='success')
+            kallithea.lib.indexers.daemon.whoosh_index(repo_location, full_index)
+            webutils.flash(_('Whoosh reindex task scheduled'), category='success')
             raise HTTPFound(location=url('admin_settings_search'))
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -418,17 +395,16 b' class SettingsController(BaseController)'
     def settings_system(self):
         c.active = 'system'
 
-        defaults = Setting.get_app_settings()
+        defaults = db.Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
 
-        import kallithea
         c.ini = kallithea.CONFIG
-        server_info = Setting.get_server_info()
+        server_info = db.Setting.get_server_info()
         for key, val in server_info.items():
             setattr(c, key, val)
 
         return htmlfill.render(
-            render('admin/settings/settings.html'),
+            base.render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)

kallithea/controllers/admin/user_groups.py

@@ -37,16 +37,15 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound, HTTPInternalServerError
 
-from kallithea.config.routing import url
-from kallithea.lib import helpers as h
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, HasUserGroupPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseController, render
 from kallithea.lib.exceptions import RepoGroupAssignmentError, UserGroupsAssignedException
-from kallithea.lib.utils import action_logger
 from kallithea.lib.utils2 import safe_int, safe_str
-from kallithea.model.db import User, UserGroup, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta, userlog
 from kallithea.model.forms import CustomDefaultPermissionsForm, UserGroupForm, UserGroupPermsForm
-from kallithea.model.meta import Session
 from kallithea.model.scm import UserGroupList
 from kallithea.model.user_group import UserGroupModel
 
@@ -54,8 +53,7 b' from kallithea.model.user_group import U'
 log = logging.getLogger(__name__)
 
 
-class UserGroupsController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
+class UserGroupsController(base.BaseController):
 
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
@@ -67,7 +65,7 b' class UserGroupsController(BaseControlle'
 
         c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
         c.available_members = sorted(((x.user_id, x.username) for x in
-                                      User.query().all()),
+                                      db.User.query().all()),
                                      key=lambda u: u[1].lower())
 
     def __load_defaults(self, user_group_id):
@@ -76,13 +74,13 b' class UserGroupsController(BaseControlle'
 
         :param user_group_id:
         """
-        user_group = UserGroup.get_or_404(user_group_id)
+        user_group = db.UserGroup.get_or_404(user_group_id)
         data = user_group.get_dict()
         return data
 
     def index(self, format='html'):
-        _list = UserGroup.query() \
-                        .order_by(func.lower(UserGroup.users_group_name)) \
+        _list = db.UserGroup.query() \
+                        .order_by(func.lower(db.UserGroup.users_group_name)) \
                         .all()
         group_iter = UserGroupList(_list, perm_level='admin')
         user_groups_data = []
@@ -91,21 +89,21 b' class UserGroupsController(BaseControlle'
 
         def user_group_name(user_group_id, user_group_name):
             return template.get_def("user_group_name") \
-                .render_unicode(user_group_id, user_group_name, _=_, h=h, c=c)
+                .render_unicode(user_group_id, user_group_name, _=_, webutils=webutils, c=c)
 
         def user_group_actions(user_group_id, user_group_name):
             return template.get_def("user_group_actions") \
-                .render_unicode(user_group_id, user_group_name, _=_, h=h, c=c)
+                .render_unicode(user_group_id, user_group_name, _=_, webutils=webutils, c=c)
 
         for user_gr in group_iter:
             user_groups_data.append({
                 "raw_name": user_gr.users_group_name,
                 "group_name": user_group_name(user_gr.users_group_id,
                                               user_gr.users_group_name),
-                "desc": h.escape(user_gr.user_group_description),
+                "desc": webutils.escape(user_gr.user_group_description),
                 "members": len(user_gr.members),
                 "active": h.boolicon(user_gr.users_group_active),
-                "owner": h.person(user_gr.owner.username),
+                "owner": user_gr.owner.username,
                 "action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name)
             })
 
@@ -115,7 +113,7 b' class UserGroupsController(BaseControlle'
             "records": user_groups_data
         }
 
-        return render('admin/user_groups/user_groups.html')
+        return base.render('admin/user_groups/user_groups.html')
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
     def create(self):
@@ -128,15 +126,15 b' class UserGroupsController(BaseControlle'
                                          active=form_result['users_group_active'])
 
             gr = form_result['users_group_name']
-            action_logger(request.authuser,
+            userlog.action_logger(request.authuser,
                           'admin_created_users_group:%s' % gr,
                           None, request.ip_addr)
-            h.flash(h.HTML(_('Created user group %s')) % h.link_to(gr, url('edit_users_group', id=ug.users_group_id)),
+            webutils.flash(webutils.HTML(_('Created user group %s')) % webutils.link_to(gr, url('edit_users_group', id=ug.users_group_id)),
                 category='success')
-            Session().commit()
+            meta.Session().commit()
         except formencode.Invalid as errors:
             return htmlfill.render(
-                render('admin/user_groups/user_group_add.html'),
+                base.render('admin/user_groups/user_group_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -144,18 +142,18 b' class UserGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during creation of user group %s')
+            webutils.flash(_('Error occurred during creation of user group %s')
                     % request.POST.get('users_group_name'), category='error')
 
         raise HTTPFound(location=url('users_groups'))
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
     def new(self, format='html'):
-        return render('admin/user_groups/user_group_add.html')
+        return base.render('admin/user_groups/user_group_add.html')
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def update(self, id):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'settings'
         self.__load_data(id)
 
@@ -169,11 +167,11 b' class UserGroupsController(BaseControlle'
             form_result = users_group_form.to_python(request.POST)
             UserGroupModel().update(c.user_group, form_result)
             gr = form_result['users_group_name']
-            action_logger(request.authuser,
+            userlog.action_logger(request.authuser,
                           'admin_updated_users_group:%s' % gr,
                           None, request.ip_addr)
-            h.flash(_('Updated user group %s') % gr, category='success')
-            Session().commit()
+            webutils.flash(_('Updated user group %s') % gr, category='success')
+            meta.Session().commit()
         except formencode.Invalid as errors:
             ug_model = UserGroupModel()
             defaults = errors.value
@@ -186,7 +184,7 b' class UserGroupsController(BaseControlle'
             })
 
             return htmlfill.render(
-                render('admin/user_groups/user_group_edit.html'),
+                base.render('admin/user_groups/user_group_edit.html'),
                 defaults=defaults,
                 errors=e,
                 prefix_error=False,
@@ -194,36 +192,36 b' class UserGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of user group %s')
+            webutils.flash(_('Error occurred during update of user group %s')
                     % request.POST.get('users_group_name'), category='error')
 
         raise HTTPFound(location=url('edit_users_group', id=id))
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def delete(self, id):
-        usr_gr = UserGroup.get_or_404(id)
+        usr_gr = db.UserGroup.get_or_404(id)
         try:
             UserGroupModel().delete(usr_gr)
-            Session().commit()
-            h.flash(_('Successfully deleted user group'), category='success')
+            meta.Session().commit()
+            webutils.flash(_('Successfully deleted user group'), category='success')
         except UserGroupsAssignedException as e:
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during deletion of user group'),
+            webutils.flash(_('An error occurred during deletion of user group'),
                     category='error')
         raise HTTPFound(location=url('users_groups'))
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def edit(self, id, format='html'):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'settings'
         self.__load_data(id)
 
         defaults = self.__load_defaults(id)
 
         return htmlfill.render(
-            render('admin/user_groups/user_group_edit.html'),
+            base.render('admin/user_groups/user_group_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -231,7 +229,7 b' class UserGroupsController(BaseControlle'
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def edit_perms(self, id):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'perms'
 
         defaults = {}
@@ -245,7 +243,7 b' class UserGroupsController(BaseControlle'
                              p.permission.permission_name})
 
         return htmlfill.render(
-            render('admin/user_groups/user_group_edit.html'),
+            base.render('admin/user_groups/user_group_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -258,7 +256,7 b' class UserGroupsController(BaseControlle'
 
         :param id:
         """
-        user_group = UserGroup.get_or_404(id)
+        user_group = db.UserGroup.get_or_404(id)
         form = UserGroupPermsForm()().to_python(request.POST)
 
         # set the permissions !
@@ -266,13 +264,13 b' class UserGroupsController(BaseControlle'
             UserGroupModel()._update_permissions(user_group, form['perms_new'],
                                                  form['perms_updates'])
         except RepoGroupAssignmentError:
-            h.flash(_('Target group cannot be the same'), category='error')
+            webutils.flash(_('Target group cannot be the same'), category='error')
             raise HTTPFound(location=url('edit_user_group_perms', id=id))
         # TODO: implement this
         #action_logger(request.authuser, 'admin_changed_repo_permissions',
         #              repo_name, request.ip_addr)
-        Session().commit()
-        h.flash(_('User group permissions updated'), category='success')
+        meta.Session().commit()
+        webutils.flash(_('User group permissions updated'), category='success')
         raise HTTPFound(location=url('edit_user_group_perms', id=id))
 
     @HasUserGroupPermissionLevelDecorator('admin')
@@ -288,7 +286,7 b' class UserGroupsController(BaseControlle'
             if not request.authuser.is_admin:
                 if obj_type == 'user' and request.authuser.user_id == obj_id:
                     msg = _('Cannot revoke permission for yourself as admin')
-                    h.flash(msg, category='warning')
+                    webutils.flash(msg, category='warning')
                     raise Exception('revoke admin permission on self')
             if obj_type == 'user':
                 UserGroupModel().revoke_user_permission(user_group=id,
@@ -296,36 +294,36 b' class UserGroupsController(BaseControlle'
             elif obj_type == 'user_group':
                 UserGroupModel().revoke_user_group_permission(target_user_group=id,
                                                               user_group=obj_id)
-            Session().commit()
+            meta.Session().commit()
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during revoking of permission'),
+            webutils.flash(_('An error occurred during revoking of permission'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def edit_default_perms(self, id):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'default_perms'
 
         permissions = {
             'repositories': {},
             'repositories_groups': {}
         }
-        ugroup_repo_perms = UserGroupRepoToPerm.query() \
-            .options(joinedload(UserGroupRepoToPerm.permission)) \
-            .options(joinedload(UserGroupRepoToPerm.repository)) \
-            .filter(UserGroupRepoToPerm.users_group_id == id) \
+        ugroup_repo_perms = db.UserGroupRepoToPerm.query() \
+            .options(joinedload(db.UserGroupRepoToPerm.permission)) \
+            .options(joinedload(db.UserGroupRepoToPerm.repository)) \
+            .filter(db.UserGroupRepoToPerm.users_group_id == id) \
             .all()
 
         for gr in ugroup_repo_perms:
             permissions['repositories'][gr.repository.repo_name]  \
                 = gr.permission.permission_name
 
-        ugroup_group_perms = UserGroupRepoGroupToPerm.query() \
-            .options(joinedload(UserGroupRepoGroupToPerm.permission)) \
-            .options(joinedload(UserGroupRepoGroupToPerm.group)) \
-            .filter(UserGroupRepoGroupToPerm.users_group_id == id) \
+        ugroup_group_perms = db.UserGroupRepoGroupToPerm.query() \
+            .options(joinedload(db.UserGroupRepoGroupToPerm.permission)) \
+            .options(joinedload(db.UserGroupRepoGroupToPerm.group)) \
+            .filter(db.UserGroupRepoGroupToPerm.users_group_id == id) \
             .all()
 
         for gr in ugroup_group_perms:
@@ -346,7 +344,7 b' class UserGroupsController(BaseControlle'
         })
 
         return htmlfill.render(
-            render('admin/user_groups/user_group_edit.html'),
+            base.render('admin/user_groups/user_group_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
@@ -354,7 +352,7 b' class UserGroupsController(BaseControlle'
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def update_default_perms(self, id):
-        user_group = UserGroup.get_or_404(id)
+        user_group = db.UserGroup.get_or_404(id)
 
         try:
             form = CustomDefaultPermissionsForm()()
@@ -362,11 +360,11 b' class UserGroupsController(BaseControlle'
 
             usergroup_model = UserGroupModel()
 
-            defs = UserGroupToPerm.query() \
-                .filter(UserGroupToPerm.users_group == user_group) \
+            defs = db.UserGroupToPerm.query() \
+                .filter(db.UserGroupToPerm.users_group == user_group) \
                 .all()
             for ug in defs:
-                Session().delete(ug)
+                meta.Session().delete(ug)
 
             if form_result['create_repo_perm']:
                 usergroup_model.grant_perm(id, 'hg.create.repository')
@@ -381,29 +379,29 b' class UserGroupsController(BaseControlle'
             else:
                 usergroup_model.grant_perm(id, 'hg.fork.none')
 
-            h.flash(_("Updated permissions"), category='success')
-            Session().commit()
+            webutils.flash(_("Updated permissions"), category='success')
+            meta.Session().commit()
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during permissions saving'),
+            webutils.flash(_('An error occurred during permissions saving'),
                     category='error')
 
         raise HTTPFound(location=url('edit_user_group_default_perms', id=id))
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def edit_advanced(self, id):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'advanced'
         c.group_members_obj = sorted((x.user for x in c.user_group.members),
                                      key=lambda u: u.username.lower())
-        return render('admin/user_groups/user_group_edit.html')
+        return base.render('admin/user_groups/user_group_edit.html')
 
     @HasUserGroupPermissionLevelDecorator('admin')
     def edit_members(self, id):
-        c.user_group = UserGroup.get_or_404(id)
+        c.user_group = db.UserGroup.get_or_404(id)
         c.active = 'members'
         c.group_members_obj = sorted((x.user for x in c.user_group.members),
                                      key=lambda u: u.username.lower())
 
         c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
-        return render('admin/user_groups/user_group_edit.html')
+        return base.render('admin/user_groups/user_group_edit.html')

kallithea/controllers/admin/users.py

@@ -37,18 +37,16 b' from tg.i18n import ugettext as _'
 from webob.exc import HTTPFound, HTTPNotFound
 
 import kallithea
-from kallithea.config.routing import url
-from kallithea.lib import auth_modules
-from kallithea.lib import helpers as h
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.lib import auth_modules, webutils
 from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired
-from kallithea.lib.base import BaseController, IfSshEnabled, render
 from kallithea.lib.exceptions import DefaultUserException, UserCreationError, UserOwnsReposException
-from kallithea.lib.utils import action_logger
 from kallithea.lib.utils2 import datetime_to_time, generate_api_key, safe_int
+from kallithea.lib.webutils import fmt_date, url
+from kallithea.model import db, meta, userlog
 from kallithea.model.api_key import ApiKeyModel
-from kallithea.model.db import User, UserEmailMap, UserIpMap, UserToPerm
 from kallithea.model.forms import CustomDefaultPermissionsForm, UserForm
-from kallithea.model.meta import Session
 from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException
 from kallithea.model.user import UserModel
 
@@ -56,8 +54,7 b' from kallithea.model.user import UserMod'
 log = logging.getLogger(__name__)
 
 
-class UsersController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
+class UsersController(base.BaseController):
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
@@ -65,9 +62,9 b' class UsersController(BaseController):'
         super(UsersController, self)._before(*args, **kwargs)
 
     def index(self, format='html'):
-        c.users_list = User.query().order_by(User.username) \
+        c.users_list = db.User.query().order_by(db.User.username) \
                         .filter_by(is_default_user=False) \
-                        .order_by(func.lower(User.username)) \
+                        .order_by(func.lower(db.User.username)) \
                         .all()
 
         users_data = []
@@ -78,20 +75,20 b' class UsersController(BaseController):'
 
         def username(user_id, username):
             return template.get_def("user_name") \
-                .render_unicode(user_id, username, _=_, h=h, c=c)
+                .render_unicode(user_id, username, _=_, webutils=webutils, c=c)
 
         def user_actions(user_id, username):
             return template.get_def("user_actions") \
-                .render_unicode(user_id, username, _=_, h=h, c=c)
+                .render_unicode(user_id, username, _=_, webutils=webutils, c=c)
 
         for user in c.users_list:
             users_data.append({
                 "gravatar": grav_tmpl % h.gravatar(user.email, size=20),
                 "raw_name": user.username,
                 "username": username(user.user_id, user.username),
-                "firstname": h.escape(user.name),
-                "lastname": h.escape(user.lastname),
-                "last_login": h.fmt_date(user.last_login),
+                "firstname": webutils.escape(user.name),
+                "lastname": webutils.escape(user.lastname),
+                "last_login": fmt_date(user.last_login),
                 "last_login_raw": datetime_to_time(user.last_login),
                 "active": h.boolicon(user.active),
                 "admin": h.boolicon(user.admin),
@@ -106,41 +103,41 b' class UsersController(BaseController):'
             "records": users_data
         }
 
-        return render('admin/users/users.html')
+        return base.render('admin/users/users.html')
 
     def create(self):
-        c.default_extern_type = User.DEFAULT_AUTH_TYPE
+        c.default_extern_type = db.User.DEFAULT_AUTH_TYPE
         c.default_extern_name = ''
         user_model = UserModel()
         user_form = UserForm()()
         try:
             form_result = user_form.to_python(dict(request.POST))
             user = user_model.create(form_result)
-            action_logger(request.authuser, 'admin_created_user:%s' % user.username,
+            userlog.action_logger(request.authuser, 'admin_created_user:%s' % user.username,
                           None, request.ip_addr)
-            h.flash(_('Created user %s') % user.username,
+            webutils.flash(_('Created user %s') % user.username,
                     category='success')
-            Session().commit()
+            meta.Session().commit()
         except formencode.Invalid as errors:
             return htmlfill.render(
-                render('admin/users/user_add.html'),
+                base.render('admin/users/user_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
         except UserCreationError as e:
-            h.flash(e, 'error')
+            webutils.flash(e, 'error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during creation of user %s')
+            webutils.flash(_('Error occurred during creation of user %s')
                     % request.POST.get('username'), category='error')
         raise HTTPFound(location=url('edit_user', id=user.user_id))
 
     def new(self, format='html'):
-        c.default_extern_type = User.DEFAULT_AUTH_TYPE
+        c.default_extern_type = db.User.DEFAULT_AUTH_TYPE
         c.default_extern_name = ''
-        return render('admin/users/user_add.html')
+        return base.render('admin/users/user_add.html')
 
     def update(self, id):
         user_model = UserModel()
@@ -155,10 +152,10 b' class UsersController(BaseController):'
 
             user_model.update(id, form_result, skip_attrs=skip_attrs)
             usr = form_result['username']
-            action_logger(request.authuser, 'admin_updated_user:%s' % usr,
+            userlog.action_logger(request.authuser, 'admin_updated_user:%s' % usr,
                           None, request.ip_addr)
-            h.flash(_('User updated successfully'), category='success')
-            Session().commit()
+            webutils.flash(_('User updated successfully'), category='success')
+            meta.Session().commit()
         except formencode.Invalid as errors:
             defaults = errors.value
             e = errors.error_dict or {}
@@ -176,29 +173,33 b' class UsersController(BaseController):'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of user %s')
+            webutils.flash(_('Error occurred during update of user %s')
                     % form_result.get('username'), category='error')
         raise HTTPFound(location=url('edit_user', id=id))
 
     def delete(self, id):
-        usr = User.get_or_404(id)
+        usr = db.User.get_or_404(id)
+        has_ssh_keys = bool(usr.ssh_keys)
         try:
             UserModel().delete(usr)
-            Session().commit()
-            h.flash(_('Successfully deleted user'), category='success')
+            meta.Session().commit()
+            webutils.flash(_('Successfully deleted user'), category='success')
         except (UserOwnsReposException, DefaultUserException) as e:
-            h.flash(e, category='warning')
+            webutils.flash(e, category='warning')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during deletion of user'),
+            webutils.flash(_('An error occurred during deletion of user'),
                     category='error')
+        else:
+            if has_ssh_keys:
+                SshKeyModel().write_authorized_keys()
         raise HTTPFound(location=url('users'))
 
     def _get_user_or_raise_if_default(self, id):
         try:
-            return User.get_or_404(id, allow_default=False)
+            return db.User.get_or_404(id, allow_default=False)
         except DefaultUserException:
-            h.flash(_("The default user cannot be edited"), category='warning')
+            webutils.flash(_("The default user cannot be edited"), category='warning')
             raise HTTPNotFound
 
     def _render_edit_profile(self, user):
@@ -207,7 +208,7 b' class UsersController(BaseController):'
         c.perm_user = AuthUser(dbuser=user)
         managed_fields = auth_modules.get_managed_fields(user)
         c.readonly = lambda n: 'readonly' if n in managed_fields else None
-        return render('admin/users/user_edit.html')
+        return base.render('admin/users/user_edit.html')
 
     def edit(self, id, format='html'):
         user = self._get_user_or_raise_if_default(id)
@@ -233,7 +234,7 b' class UsersController(BaseController):'
             'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'),
         })
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -254,7 +255,7 b' class UsersController(BaseController):'
                                                      show_expired=show_expired)
         defaults = c.user.get_dict()
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -265,8 +266,8 b' class UsersController(BaseController):'
         lifetime = safe_int(request.POST.get('lifetime'), -1)
         description = request.POST.get('description')
         ApiKeyModel().create(c.user.user_id, description, lifetime)
-        Session().commit()
-        h.flash(_("API key successfully created"), category='success')
+        meta.Session().commit()
+        webutils.flash(_("API key successfully created"), category='success')
         raise HTTPFound(location=url('edit_user_api_keys', id=c.user.user_id))
 
     def delete_api_key(self, id):
@@ -275,12 +276,12 b' class UsersController(BaseController):'
         api_key = request.POST.get('del_api_key')
         if request.POST.get('del_api_key_builtin'):
             c.user.api_key = generate_api_key()
-            Session().commit()
-            h.flash(_("API key successfully reset"), category='success')
+            meta.Session().commit()
+            webutils.flash(_("API key successfully reset"), category='success')
         elif api_key:
             ApiKeyModel().delete(api_key, c.user.user_id)
-            Session().commit()
-            h.flash(_("API key successfully deleted"), category='success')
+            meta.Session().commit()
+            webutils.flash(_("API key successfully deleted"), category='success')
 
         raise HTTPFound(location=url('edit_user_api_keys', id=c.user.user_id))
 
@@ -301,7 +302,7 b' class UsersController(BaseController):'
             'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'),
         })
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -315,11 +316,11 b' class UsersController(BaseController):'
 
             user_model = UserModel()
 
-            defs = UserToPerm.query() \
-                .filter(UserToPerm.user == user) \
+            defs = db.UserToPerm.query() \
+                .filter(db.UserToPerm.user == user) \
                 .all()
             for ug in defs:
-                Session().delete(ug)
+                meta.Session().delete(ug)
 
             if form_result['create_repo_perm']:
                 user_model.grant_perm(id, 'hg.create.repository')
@@ -333,23 +334,23 b' class UsersController(BaseController):'
                 user_model.grant_perm(id, 'hg.fork.repository')
             else:
                 user_model.grant_perm(id, 'hg.fork.none')
-            h.flash(_("Updated permissions"), category='success')
-            Session().commit()
+            webutils.flash(_("Updated permissions"), category='success')
+            meta.Session().commit()
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during permissions saving'),
+            webutils.flash(_('An error occurred during permissions saving'),
                     category='error')
         raise HTTPFound(location=url('edit_user_perms', id=id))
 
     def edit_emails(self, id):
         c.user = self._get_user_or_raise_if_default(id)
         c.active = 'emails'
-        c.user_email_map = UserEmailMap.query() \
-            .filter(UserEmailMap.user == c.user).all()
+        c.user_email_map = db.UserEmailMap.query() \
+            .filter(db.UserEmailMap.user == c.user).all()
 
         defaults = c.user.get_dict()
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -361,14 +362,14 b' class UsersController(BaseController):'
 
         try:
             user_model.add_extra_email(id, email)
-            Session().commit()
-            h.flash(_("Added email %s to user") % email, category='success')
+            meta.Session().commit()
+            webutils.flash(_("Added email %s to user") % email, category='success')
         except formencode.Invalid as error:
             msg = error.error_dict['email']
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during email saving'),
+            webutils.flash(_('An error occurred during email saving'),
                     category='error')
         raise HTTPFound(location=url('edit_user_emails', id=id))
 
@@ -377,22 +378,22 b' class UsersController(BaseController):'
         email_id = request.POST.get('del_email_id')
         user_model = UserModel()
         user_model.delete_extra_email(id, email_id)
-        Session().commit()
-        h.flash(_("Removed email from user"), category='success')
+        meta.Session().commit()
+        webutils.flash(_("Removed email from user"), category='success')
         raise HTTPFound(location=url('edit_user_emails', id=id))
 
     def edit_ips(self, id):
         c.user = self._get_user_or_raise_if_default(id)
         c.active = 'ips'
-        c.user_ip_map = UserIpMap.query() \
-            .filter(UserIpMap.user == c.user).all()
+        c.user_ip_map = db.UserIpMap.query() \
+            .filter(db.UserIpMap.user == c.user).all()
 
-        c.default_user_ip_map = UserIpMap.query() \
-            .filter(UserIpMap.user_id == kallithea.DEFAULT_USER_ID).all()
+        c.default_user_ip_map = db.UserIpMap.query() \
+            .filter(db.UserIpMap.user_id == kallithea.DEFAULT_USER_ID).all()
 
         defaults = c.user.get_dict()
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -403,14 +404,14 b' class UsersController(BaseController):'
 
         try:
             user_model.add_extra_ip(id, ip)
-            Session().commit()
-            h.flash(_("Added IP address %s to user whitelist") % ip, category='success')
+            meta.Session().commit()
+            webutils.flash(_("Added IP address %s to user whitelist") % ip, category='success')
         except formencode.Invalid as error:
             msg = error.error_dict['ip']
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred while adding IP address'),
+            webutils.flash(_('An error occurred while adding IP address'),
                     category='error')
 
         if 'default_user' in request.POST:
@@ -421,26 +422,26 b' class UsersController(BaseController):'
         ip_id = request.POST.get('del_ip_id')
         user_model = UserModel()
         user_model.delete_extra_ip(id, ip_id)
-        Session().commit()
-        h.flash(_("Removed IP address from user whitelist"), category='success')
+        meta.Session().commit()
+        webutils.flash(_("Removed IP address from user whitelist"), category='success')
 
         if 'default_user' in request.POST:
             raise HTTPFound(location=url('admin_permissions_ips'))
         raise HTTPFound(location=url('edit_user_ips', id=id))
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def edit_ssh_keys(self, id):
         c.user = self._get_user_or_raise_if_default(id)
         c.active = 'ssh_keys'
         c.user_ssh_keys = SshKeyModel().get_ssh_keys(c.user.user_id)
         defaults = c.user.get_dict()
         return htmlfill.render(
-            render('admin/users/user_edit.html'),
+            base.render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def ssh_keys_add(self, id):
         c.user = self._get_user_or_raise_if_default(id)
 
@@ -449,23 +450,23 b' class UsersController(BaseController):'
         try:
             new_ssh_key = SshKeyModel().create(c.user.user_id,
                                                description, public_key)
-            Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
+            webutils.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))
 
-    @IfSshEnabled
+    @base.IfSshEnabled
     def ssh_keys_delete(self, id):
         c.user = self._get_user_or_raise_if_default(id)
 
         fingerprint = request.POST.get('del_public_key_fingerprint')
         try:
             SshKeyModel().delete(fingerprint, c.user.user_id)
-            Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key successfully deleted"), category='success')
+            webutils.flash(_("SSH key successfully deleted"), category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))

kallithea/controllers/api/__init__.py

@@ -35,12 +35,11 b' import types'
 from tg import Response, TGController, request, response
 from webob.exc import HTTPError, HTTPException
 
+from kallithea.controllers import base
 from kallithea.lib import ext_json
 from kallithea.lib.auth import AuthUser
-from kallithea.lib.base import _get_ip_addr as _get_ip
-from kallithea.lib.base import get_path_info
 from kallithea.lib.utils2 import ascii_bytes
-from kallithea.model.db import User
+from kallithea.model import db
 
 
 log = logging.getLogger('JSONRPC')
@@ -83,9 +82,6 b' class JSONRPCController(TGController):'
 
      """
 
-    def _get_ip_addr(self, environ):
-        return _get_ip(environ)
-
     def _get_method_args(self):
         """
         Return `self._rpc_args` to dispatched controller method
@@ -103,7 +99,7 b' class JSONRPCController(TGController):'
 
         environ = state.request.environ
         start = time.time()
-        ip_addr = self._get_ip_addr(environ)
+        ip_addr = base.get_ip_addr(environ)
         self._req_id = None
         if 'CONTENT_LENGTH' not in environ:
             log.debug("No Content-Length")
@@ -145,7 +141,7 b' class JSONRPCController(TGController):'
 
         # check if we can find this session using api_key
         try:
-            u = User.get_by_api_key(self._req_api_key)
+            u = db.User.get_by_api_key(self._req_api_key)
             auth_user = AuthUser.make(dbuser=u, ip_addr=ip_addr)
             if auth_user is None:
                 raise JSONRPCErrorResponse(retid=self._req_id,
@@ -208,8 +204,8 b' class JSONRPCController(TGController):'
         self._rpc_args['environ'] = environ
 
         log.info('IP: %s Request to %s time: %.3fs' % (
-            self._get_ip_addr(environ),
-            get_path_info(environ), time.time() - start)
+            base.get_ip_addr(environ),
+            base.get_path_info(environ), time.time() - start)
         )
 
         state.set_action(self._rpc_call, [])

kallithea/controllers/api/api.py

@@ -35,15 +35,13 b' from kallithea.controllers.api import JS'
 from kallithea.lib.auth import (AuthUser, HasPermissionAny, HasPermissionAnyDecorator, HasRepoGroupPermissionLevel, HasRepoPermissionLevel,
                                 HasUserGroupPermissionLevel)
 from kallithea.lib.exceptions import DefaultUserException, UserGroupsAssignedException
-from kallithea.lib.utils import action_logger, repo2db_mapper
-from kallithea.lib.utils2 import OAttr, Optional
+from kallithea.lib.utils import repo2db_mapper
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.lib.vcs.exceptions import EmptyRepositoryError
+from kallithea.model import db, meta, userlog
 from kallithea.model.changeset_status import ChangesetStatusModel
 from kallithea.model.comment import ChangesetCommentsModel
-from kallithea.model.db import ChangesetStatus, Gist, Permission, PullRequest, RepoGroup, Repository, Setting, User, UserGroup, UserIpMap
 from kallithea.model.gist import GistModel
-from kallithea.model.meta import Session
 from kallithea.model.pull_request import PullRequestModel
 from kallithea.model.repo import RepoModel
 from kallithea.model.repo_group import RepoGroupModel
@@ -57,10 +55,10 b' log = logging.getLogger(__name__)'
 
 def store_update(updates, attr, name):
     """
-    Stores param in updates dict if it's not instance of Optional
-    allows easy updates of passed in params
+    Stores param in updates dict if it's not None (i.e. if user explicitly set
+    a parameter). This allows easy updates of passed in params.
     """
-    if not isinstance(attr, Optional):
+    if attr is not None:
         updates[name] = attr
 
 
@@ -94,7 +92,7 b' def get_repo_group_or_error(repogroupid)'
 
     :param repogroupid:
     """
-    repo_group = RepoGroup.guess_instance(repogroupid)
+    repo_group = db.RepoGroup.guess_instance(repogroupid)
     if repo_group is None:
         raise JSONRPCError(
             'repository group `%s` does not exist' % (repogroupid,))
@@ -119,7 +117,7 b' def get_perm_or_error(permid, prefix=Non'
 
     :param permid:
     """
-    perm = Permission.get_by_key(permid)
+    perm = db.Permission.get_by_key(permid)
     if perm is None:
         raise JSONRPCError('permission `%s` does not exist' % (permid,))
     if prefix:
@@ -161,7 +159,7 b' class ApiController(JSONRPCController):'
         return args
 
     @HasPermissionAnyDecorator('hg.admin')
-    def pull(self, repoid, clone_uri=Optional(None)):
+    def pull(self, repoid, clone_uri=None):
         """
         Triggers a pull from remote location on given repo. Can be used to
         automatically keep remote repos up to date. This command can be executed
@@ -197,7 +195,7 b' class ApiController(JSONRPCController):'
             ScmModel().pull_changes(repo.repo_name,
                                     request.authuser.username,
                                     request.ip_addr,
-                                    clone_uri=Optional.extract(clone_uri))
+                                    clone_uri=clone_uri)
             return dict(
                 msg='Pulled from `%s`' % repo.repo_name,
                 repository=repo.repo_name
@@ -209,7 +207,7 b' class ApiController(JSONRPCController):'
             )
 
     @HasPermissionAnyDecorator('hg.admin')
-    def rescan_repos(self, remove_obsolete=Optional(False)):
+    def rescan_repos(self, remove_obsolete=False):
         """
         Triggers rescan repositories action. If remove_obsolete is set
         than also delete repos that are in database but not in the filesystem.
@@ -240,7 +238,7 b' class ApiController(JSONRPCController):'
         """
 
         try:
-            rm_obsolete = Optional.extract(remove_obsolete)
+            rm_obsolete = remove_obsolete
             added, removed = repo2db_mapper(ScmModel().repo_scan(),
                                             remove_obsolete=rm_obsolete)
             return {'added': added, 'removed': removed}
@@ -295,7 +293,7 b' class ApiController(JSONRPCController):'
             )
 
     @HasPermissionAnyDecorator('hg.admin')
-    def get_ip(self, userid=Optional(OAttr('apiuser'))):
+    def get_ip(self, userid=None):
         """
         Shows IP address as seen from Kallithea server, together with all
         defined IP addresses for given user. If userid is not passed data is
@@ -321,10 +319,10 b' class ApiController(JSONRPCController):'
             }
 
         """
-        if isinstance(userid, Optional):
+        if userid is None:
             userid = request.authuser.user_id
         user = get_user_or_error(userid)
-        ips = UserIpMap.query().filter(UserIpMap.user == user).all()
+        ips = db.UserIpMap.query().filter(db.UserIpMap.user == user).all()
         return dict(
             server_ip_addr=request.ip_addr,
             user_ips=ips
@@ -350,9 +348,9 b' class ApiController(JSONRPCController):'
           }
           error :  null
         """
-        return Setting.get_server_info()
+        return db.Setting.get_server_info()
 
-    def get_user(self, userid=Optional(OAttr('apiuser'))):
+    def get_user(self, userid=None):
         """
         Gets a user by username or user_id, Returns empty result if user is
         not found. If userid param is skipped it is set to id of user who is
@@ -397,12 +395,12 b' class ApiController(JSONRPCController):'
         if not HasPermissionAny('hg.admin')():
             # make sure normal user does not pass someone else userid,
             # he is not allowed to do that
-            if not isinstance(userid, Optional) and userid != request.authuser.user_id:
+            if userid is not None and userid != request.authuser.user_id:
                 raise JSONRPCError(
                     'userid is not the same as your user'
                 )
 
-        if isinstance(userid, Optional):
+        if userid is None:
             userid = request.authuser.user_id
 
         user = get_user_or_error(userid)
@@ -426,17 +424,17 b' class ApiController(JSONRPCController):'
 
         return [
             user.get_api_data()
-            for user in User.query()
-                .order_by(User.username)
+            for user in db.User.query()
+                .order_by(db.User.username)
                 .filter_by(is_default_user=False)
         ]
 
     @HasPermissionAnyDecorator('hg.admin')
-    def create_user(self, username, email, password=Optional(''),
-                    firstname=Optional(''), lastname=Optional(''),
-                    active=Optional(True), admin=Optional(False),
-                    extern_type=Optional(User.DEFAULT_AUTH_TYPE),
-                    extern_name=Optional('')):
+    def create_user(self, username, email, password='',
+                    firstname='', lastname='',
+                    active=True, admin=False,
+                    extern_type=db.User.DEFAULT_AUTH_TYPE,
+                    extern_name=''):
         """
         Creates new user. Returns new user object. This command can
         be executed only using api_key belonging to user with admin rights.
@@ -484,25 +482,25 b' class ApiController(JSONRPCController):'
 
         """
 
-        if User.get_by_username(username):
+        if db.User.get_by_username(username):
             raise JSONRPCError("user `%s` already exist" % (username,))
 
-        if User.get_by_email(email):
+        if db.User.get_by_email(email):
             raise JSONRPCError("email `%s` already exist" % (email,))
 
         try:
             user = UserModel().create_or_update(
-                username=Optional.extract(username),
-                password=Optional.extract(password),
-                email=Optional.extract(email),
-                firstname=Optional.extract(firstname),
-                lastname=Optional.extract(lastname),
-                active=Optional.extract(active),
-                admin=Optional.extract(admin),
-                extern_type=Optional.extract(extern_type),
-                extern_name=Optional.extract(extern_name)
+                username=username,
+                password=password,
+                email=email,
+                firstname=firstname,
+                lastname=lastname,
+                active=active,
+                admin=admin,
+                extern_type=extern_type,
+                extern_name=extern_name
             )
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='created new user `%s`' % username,
                 user=user.get_api_data()
@@ -512,11 +510,11 b' class ApiController(JSONRPCController):'
             raise JSONRPCError('failed to create user `%s`' % (username,))
 
     @HasPermissionAnyDecorator('hg.admin')
-    def update_user(self, userid, username=Optional(None),
-                    email=Optional(None), password=Optional(None),
-                    firstname=Optional(None), lastname=Optional(None),
-                    active=Optional(None), admin=Optional(None),
-                    extern_type=Optional(None), extern_name=Optional(None)):
+    def update_user(self, userid, username=None,
+                    email=None, password=None,
+                    firstname=None, lastname=None,
+                    active=None, admin=None,
+                    extern_type=None, extern_name=None):
         """
         updates given user if such user exists. This command can
         be executed only using api_key belonging to user with admin rights.
@@ -580,7 +578,7 b' class ApiController(JSONRPCController):'
             store_update(updates, extern_type, 'extern_type')
 
             user = UserModel().update_user(user, **updates)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='updated user ID:%s %s' % (user.user_id, user.username),
                 user=user.get_api_data()
@@ -623,7 +621,7 b' class ApiController(JSONRPCController):'
 
         try:
             UserModel().delete(userid)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='deleted user ID:%s %s' % (user.user_id, user.username),
                 user=None
@@ -682,12 +680,12 b' class ApiController(JSONRPCController):'
 
         return [
             user_group.get_api_data()
-            for user_group in UserGroupList(UserGroup.query().all(), perm_level='read')
+            for user_group in UserGroupList(db.UserGroup.query().all(), perm_level='read')
         ]
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
-    def create_user_group(self, group_name, description=Optional(''),
-                          owner=Optional(OAttr('apiuser')), active=Optional(True)):
+    def create_user_group(self, group_name, description='',
+                          owner=None, active=True):
         """
         Creates new user group. This command can be executed only using api_key
         belonging to user with admin rights or an user who has create user group
@@ -727,15 +725,13 b' class ApiController(JSONRPCController):'
             raise JSONRPCError("user group `%s` already exist" % (group_name,))
 
         try:
-            if isinstance(owner, Optional):
+            if owner is None:
                 owner = request.authuser.user_id
 
             owner = get_user_or_error(owner)
-            active = Optional.extract(active)
-            description = Optional.extract(description)
             ug = UserGroupModel().create(name=group_name, description=description,
                                          owner=owner, active=active)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='created new user group `%s`' % group_name,
                 user_group=ug.get_api_data()
@@ -745,9 +741,9 b' class ApiController(JSONRPCController):'
             raise JSONRPCError('failed to create group `%s`' % (group_name,))
 
     # permission check inside
-    def update_user_group(self, usergroupid, group_name=Optional(''),
-                          description=Optional(''), owner=Optional(None),
-                          active=Optional(True)):
+    def update_user_group(self, usergroupid, group_name=None,
+                          description=None, owner=None,
+                          active=None):
         """
         Updates given usergroup.  This command can be executed only using api_key
         belonging to user with admin rights or an admin of given user group
@@ -786,7 +782,7 b' class ApiController(JSONRPCController):'
             if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
 
-        if not isinstance(owner, Optional):
+        if owner is not None:
             owner = get_user_or_error(owner)
 
         updates = {}
@@ -796,7 +792,7 b' class ApiController(JSONRPCController):'
         store_update(updates, active, 'users_group_active')
         try:
             UserGroupModel().update(user_group, updates)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='updated user group ID:%s %s' % (user_group.users_group_id,
                                                      user_group.users_group_name),
@@ -842,7 +838,7 b' class ApiController(JSONRPCController):'
 
         try:
             UserGroupModel().delete(user_group)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='deleted user group ID:%s %s' %
                     (user_group.users_group_id, user_group.users_group_name),
@@ -903,7 +899,7 b' class ApiController(JSONRPCController):'
                 user.username, user_group.users_group_name
             )
             msg = msg if success else 'User is already in that group'
-            Session().commit()
+            meta.Session().commit()
 
             return dict(
                 success=success,
@@ -951,7 +947,7 b' class ApiController(JSONRPCController):'
                 user.username, user_group.users_group_name
             )
             msg = msg if success else "User wasn't in group"
-            Session().commit()
+            meta.Session().commit()
             return dict(success=success, msg=msg)
         except Exception:
             log.error(traceback.format_exc())
@@ -963,8 +959,8 b' class ApiController(JSONRPCController):'
 
     # permission check inside
     def get_repo(self, repoid,
-                 with_revision_names=Optional(False),
-                 with_pullrequests=Optional(False)):
+                 with_revision_names=False,
+                 with_pullrequests=False):
         """
         Gets an existing repository by it's name or repository_id. Members will return
         either users_group or user associated to that repository. This command can be
@@ -1064,8 +1060,8 b' class ApiController(JSONRPCController):'
             for uf in repo.followers
         ]
 
-        data = repo.get_api_data(with_revision_names=Optional.extract(with_revision_names),
-                                 with_pullrequests=Optional.extract(with_pullrequests))
+        data = repo.get_api_data(with_revision_names=with_revision_names,
+                                 with_pullrequests=with_pullrequests)
         data['members'] = members
         data['followers'] = followers
         return data
@@ -1101,9 +1097,9 b' class ApiController(JSONRPCController):'
             error:  null
         """
         if not HasPermissionAny('hg.admin')():
-            repos = RepoModel().get_all_user_repos(user=request.authuser.user_id)
+            repos = request.authuser.get_all_user_repos()
         else:
-            repos = Repository.query()
+            repos = db.Repository.query()
 
         return [
             repo.get_api_data()
@@ -1112,7 +1108,7 b' class ApiController(JSONRPCController):'
 
     # permission check inside
     def get_repo_nodes(self, repoid, revision, root_path,
-                       ret_type=Optional('all')):
+                       ret_type='all'):
         """
         returns a list of nodes and it's children in a flat list for a given path
         at given revision. It's possible to specify ret_type to show only `files` or
@@ -1147,7 +1143,6 b' class ApiController(JSONRPCController):'
             if not HasRepoPermissionLevel('read')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
 
-        ret_type = Optional.extract(ret_type)
         _map = {}
         try:
             _d, _f = ScmModel().get_nodes(repo, revision, root_path,
@@ -1168,13 +1163,13 b' class ApiController(JSONRPCController):'
             )
 
     # permission check inside
-    def create_repo(self, repo_name, owner=Optional(OAttr('apiuser')),
-                    repo_type=Optional('hg'), description=Optional(''),
-                    private=Optional(False), clone_uri=Optional(None),
-                    landing_rev=Optional('rev:tip'),
-                    enable_statistics=Optional(False),
-                    enable_downloads=Optional(False),
-                    copy_permissions=Optional(False)):
+    def create_repo(self, repo_name, owner=None,
+                    repo_type=None, description='',
+                    private=False, clone_uri=None,
+                    landing_rev='rev:tip',
+                    enable_statistics=None,
+                    enable_downloads=None,
+                    copy_permissions=False):
         """
         Creates a repository. The repository name contains the full path, but the
         parent repository group must exist. For example "foo/bar/baz" require the groups
@@ -1228,7 +1223,7 b' class ApiController(JSONRPCController):'
         repo_name_parts = repo_name.split('/')
         if len(repo_name_parts) > 1:
             group_name = '/'.join(repo_name_parts[:-1])
-            repo_group = RepoGroup.get_by_group_name(group_name)
+            repo_group = db.RepoGroup.get_by_group_name(group_name)
             if repo_group is None:
                 raise JSONRPCError("repo group `%s` not found" % group_name)
             if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(group_name)):
@@ -1238,12 +1233,12 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError("no permission to create top level repo")
 
         if not HasPermissionAny('hg.admin')():
-            if not isinstance(owner, Optional):
+            if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
                 )
-        if isinstance(owner, Optional):
+        if owner is None:
             owner = request.authuser.user_id
 
         owner = get_user_or_error(owner)
@@ -1251,28 +1246,22 b' class ApiController(JSONRPCController):'
         if RepoModel().get_by_repo_name(repo_name):
             raise JSONRPCError("repo `%s` already exist" % repo_name)
 
-        defs = Setting.get_default_repo_settings(strip_prefix=True)
-        if isinstance(private, Optional):
-            private = defs.get('repo_private') or Optional.extract(private)
-        if isinstance(repo_type, Optional):
+        defs = db.Setting.get_default_repo_settings(strip_prefix=True)
+        if private is None:
+            private = defs.get('repo_private') or False
+        if repo_type is None:
             repo_type = defs.get('repo_type')
-        if isinstance(enable_statistics, Optional):
+        if enable_statistics is None:
             enable_statistics = defs.get('repo_enable_statistics')
-        if isinstance(enable_downloads, Optional):
+        if enable_downloads is None:
             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)
-
         try:
             data = dict(
                 repo_name=repo_name_parts[-1],
                 repo_name_full=repo_name,
                 repo_type=repo_type,
                 repo_description=description,
-                owner=owner,
                 repo_private=private,
                 clone_uri=clone_uri,
                 repo_group=group_name,
@@ -1282,14 +1271,12 b' class ApiController(JSONRPCController):'
                 repo_copy_permissions=copy_permissions,
             )
 
-            task = RepoModel().create(form_data=data, cur_user=owner.username)
-            task_id = task.task_id
+            RepoModel().create(form_data=data, cur_user=owner.username)
             # no commit, it's done in RepoModel, or async via celery
             return dict(
                 msg="Created new repository `%s`" % (repo_name,),
                 success=True,  # cannot return the repo data here since fork
                                # can be done async
-                task=task_id
             )
         except Exception:
             log.error(traceback.format_exc())
@@ -1297,13 +1284,13 b' class ApiController(JSONRPCController):'
                 'failed to create repository `%s`' % (repo_name,))
 
     # permission check inside
-    def update_repo(self, repoid, name=Optional(None),
-                    owner=Optional(OAttr('apiuser')),
-                    group=Optional(None),
-                    description=Optional(''), private=Optional(False),
-                    clone_uri=Optional(None), landing_rev=Optional('rev:tip'),
-                    enable_statistics=Optional(False),
-                    enable_downloads=Optional(False)):
+    def update_repo(self, repoid, name=None,
+                    owner=None,
+                    group=None,
+                    description=None, private=None,
+                    clone_uri=None, landing_rev=None,
+                    enable_statistics=None,
+                    enable_downloads=None):
 
         """
         Updates repo
@@ -1330,7 +1317,7 b' class ApiController(JSONRPCController):'
             ):
                 raise JSONRPCError('no permission to create (or move) top level repositories')
 
-            if not isinstance(owner, Optional):
+            if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
@@ -1338,7 +1325,7 b' class ApiController(JSONRPCController):'
 
         updates = {}
         repo_group = group
-        if not isinstance(repo_group, Optional):
+        if repo_group is not None:
             repo_group = get_repo_group_or_error(repo_group)  # TODO: repos can thus currently not be moved to root
             if repo_group.group_id != repo.group_id:
                 if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(repo_group.group_name)):
@@ -1356,7 +1343,7 b' class ApiController(JSONRPCController):'
             store_update(updates, enable_downloads, 'repo_enable_downloads')
 
             RepoModel().update(repo, **updates)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
                 repository=repo.get_api_data()
@@ -1368,9 +1355,9 b' class ApiController(JSONRPCController):'
     # permission check inside
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     def fork_repo(self, repoid, fork_name,
-                  owner=Optional(OAttr('apiuser')),
-                  description=Optional(''), copy_permissions=Optional(False),
-                  private=Optional(False), landing_rev=Optional('rev:tip')):
+                  owner=None,
+                  description='', copy_permissions=False,
+                  private=False, landing_rev='rev:tip'):
         """
         Creates a fork of given repo. In case of using celery this will
         immediately return success message, while fork is going to be created
@@ -1424,7 +1411,7 b' class ApiController(JSONRPCController):'
         fork_name_parts = fork_name.split('/')
         if len(fork_name_parts) > 1:
             group_name = '/'.join(fork_name_parts[:-1])
-            repo_group = RepoGroup.get_by_group_name(group_name)
+            repo_group = db.RepoGroup.get_by_group_name(group_name)
             if repo_group is None:
                 raise JSONRPCError("repo group `%s` not found" % group_name)
             if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(group_name)):
@@ -1436,7 +1423,7 b' class ApiController(JSONRPCController):'
         if HasPermissionAny('hg.admin')():
             pass
         elif HasRepoPermissionLevel('read')(repo.repo_name):
-            if not isinstance(owner, Optional):
+            if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
@@ -1444,7 +1431,7 b' class ApiController(JSONRPCController):'
         else:
             raise JSONRPCError('repository `%s` does not exist' % (repoid,))
 
-        if isinstance(owner, Optional):
+        if owner is None:
             owner = request.authuser.user_id
 
         owner = get_user_or_error(owner)
@@ -1455,22 +1442,20 b' class ApiController(JSONRPCController):'
                 repo_name_full=fork_name,
                 repo_group=group_name,
                 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),
+                description=description,
+                private=private,
+                copy_permissions=copy_permissions,
+                landing_rev=landing_rev,
                 update_after_clone=False,
                 fork_parent_id=repo.repo_id,
             )
-            task = RepoModel().create_fork(form_data, cur_user=owner.username)
+            RepoModel().create_fork(form_data, cur_user=owner.username)
             # no commit, it's done in RepoModel, or async via celery
-            task_id = task.task_id
             return dict(
                 msg='Created fork of `%s` as `%s`' % (repo.repo_name,
                                                       fork_name),
                 success=True,  # cannot return the repo data here since fork
                                # can be done async
-                task=task_id
             )
         except Exception:
             log.error(traceback.format_exc())
@@ -1480,7 +1465,7 b' class ApiController(JSONRPCController):'
             )
 
     # permission check inside
-    def delete_repo(self, repoid, forks=Optional('')):
+    def delete_repo(self, repoid, forks=''):
         """
         Deletes a repository. This command can be executed only using api_key belonging
         to user with admin rights or regular user that have admin access to repository.
@@ -1509,7 +1494,7 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
 
         try:
-            handle_forks = Optional.extract(forks)
+            handle_forks = forks
             _forks_msg = ''
             _forks = [f for f in repo.forks]
             if handle_forks == 'detach':
@@ -1523,7 +1508,7 b' class ApiController(JSONRPCController):'
                 )
 
             RepoModel().delete(repo, forks=forks)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Deleted repository `%s`%s' % (repo.repo_name, _forks_msg),
                 success=True
@@ -1564,7 +1549,7 b' class ApiController(JSONRPCController):'
 
             RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
 
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                     perm.permission_name, user.username, repo.repo_name
@@ -1604,7 +1589,7 b' class ApiController(JSONRPCController):'
         user = get_user_or_error(userid)
         try:
             RepoModel().revoke_user_permission(repo=repo, user=user)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Revoked perm for user: `%s` in repo: `%s`' % (
                     user.username, repo.repo_name
@@ -1666,7 +1651,7 b' class ApiController(JSONRPCController):'
             RepoModel().grant_user_group_permission(
                 repo=repo, group_name=user_group, perm=perm)
 
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` for user group: `%s` in '
                     'repo: `%s`' % (
@@ -1716,7 +1701,7 b' class ApiController(JSONRPCController):'
             RepoModel().revoke_user_group_permission(
                 repo=repo, group_name=user_group)
 
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Revoked perm for user group: `%s` in repo: `%s`' % (
                     user_group.users_group_name, repo.repo_name
@@ -1776,14 +1761,14 b' class ApiController(JSONRPCController):'
         """
         return [
             repo_group.get_api_data()
-            for repo_group in RepoGroup.query()
+            for repo_group in db.RepoGroup.query()
         ]
 
     @HasPermissionAnyDecorator('hg.admin')
-    def create_repo_group(self, group_name, description=Optional(''),
-                          owner=Optional(OAttr('apiuser')),
-                          parent=Optional(None),
-                          copy_permissions=Optional(False)):
+    def create_repo_group(self, group_name, description='',
+                          owner=None,
+                          parent=None,
+                          copy_permissions=False):
         """
         Creates a repository group. This command can be executed only using
         api_key belonging to user with admin rights.
@@ -1817,17 +1802,16 b' class ApiController(JSONRPCController):'
           }
 
         """
-        if RepoGroup.get_by_group_name(group_name):
+        if db.RepoGroup.get_by_group_name(group_name):
             raise JSONRPCError("repo group `%s` already exist" % (group_name,))
 
-        if isinstance(owner, Optional):
+        if owner is None:
             owner = request.authuser.user_id
-        group_description = Optional.extract(description)
-        parent_group = Optional.extract(parent)
-        if not isinstance(parent, Optional):
-            parent_group = get_repo_group_or_error(parent_group)
+        group_description = description
+        parent_group = None
+        if parent is not None:
+            parent_group = get_repo_group_or_error(parent)
 
-        copy_permissions = Optional.extract(copy_permissions)
         try:
             repo_group = RepoGroupModel().create(
                 group_name=group_name,
@@ -1836,7 +1820,7 b' class ApiController(JSONRPCController):'
                 parent=parent_group,
                 copy_permissions=copy_permissions
             )
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='created new repo group `%s`' % group_name,
                 repo_group=repo_group.get_api_data()
@@ -1847,10 +1831,10 b' class ApiController(JSONRPCController):'
             raise JSONRPCError('failed to create repo group `%s`' % (group_name,))
 
     @HasPermissionAnyDecorator('hg.admin')
-    def update_repo_group(self, repogroupid, group_name=Optional(''),
-                          description=Optional(''),
-                          owner=Optional(OAttr('apiuser')),
-                          parent=Optional(None)):
+    def update_repo_group(self, repogroupid, group_name=None,
+                          description=None,
+                          owner=None,
+                          parent=None):
         repo_group = get_repo_group_or_error(repogroupid)
 
         updates = {}
@@ -1860,7 +1844,7 b' class ApiController(JSONRPCController):'
             store_update(updates, owner, 'owner')
             store_update(updates, parent, 'parent_group')
             repo_group = RepoGroupModel().update(repo_group, updates)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='updated repository group ID:%s %s' % (repo_group.group_id,
                                                            repo_group.group_name),
@@ -1900,7 +1884,7 b' class ApiController(JSONRPCController):'
 
         try:
             RepoGroupModel().delete(repo_group)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='deleted repo group ID:%s %s' %
                     (repo_group.group_id, repo_group.group_name),
@@ -1914,7 +1898,7 b' class ApiController(JSONRPCController):'
 
     # permission check inside
     def grant_user_permission_to_repo_group(self, repogroupid, userid,
-                                            perm, apply_to_children=Optional('none')):
+                                            perm, apply_to_children='none'):
         """
         Grant permission for user on given repository group, or update existing
         one if found. This command can be executed only using api_key belonging
@@ -1956,7 +1940,6 b' class ApiController(JSONRPCController):'
 
         user = get_user_or_error(userid)
         perm = get_perm_or_error(perm, prefix='group.')
-        apply_to_children = Optional.extract(apply_to_children)
 
         try:
             RepoGroupModel().add_permission(repo_group=repo_group,
@@ -1964,7 +1947,7 b' class ApiController(JSONRPCController):'
                                             obj_type="user",
                                             perm=perm,
                                             recursive=apply_to_children)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` (recursive:%s) for user: `%s` in repo group: `%s`' % (
                     perm.permission_name, apply_to_children, user.username, repo_group.name
@@ -1979,7 +1962,7 b' class ApiController(JSONRPCController):'
 
     # permission check inside
     def revoke_user_permission_from_repo_group(self, repogroupid, userid,
-                                               apply_to_children=Optional('none')):
+                                               apply_to_children='none'):
         """
         Revoke permission for user on given repository group. This command can
         be executed only using api_key belonging to user with admin rights, or
@@ -2018,7 +2001,6 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError('repository group `%s` does not exist' % (repogroupid,))
 
         user = get_user_or_error(userid)
-        apply_to_children = Optional.extract(apply_to_children)
 
         try:
             RepoGroupModel().delete_permission(repo_group=repo_group,
@@ -2026,7 +2008,7 b' class ApiController(JSONRPCController):'
                                                obj_type="user",
                                                recursive=apply_to_children)
 
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Revoked perm (recursive:%s) for user: `%s` in repo group: `%s`' % (
                     apply_to_children, user.username, repo_group.name
@@ -2042,7 +2024,7 b' class ApiController(JSONRPCController):'
     # permission check inside
     def grant_user_group_permission_to_repo_group(
             self, repogroupid, usergroupid, perm,
-            apply_to_children=Optional('none')):
+            apply_to_children='none'):
         """
         Grant permission for user group on given repository group, or update
         existing one if found. This command can be executed only using
@@ -2089,15 +2071,13 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError(
                     'user group `%s` does not exist' % (usergroupid,))
 
-        apply_to_children = Optional.extract(apply_to_children)
-
         try:
             RepoGroupModel().add_permission(repo_group=repo_group,
                                             obj=user_group,
                                             obj_type="user_group",
                                             perm=perm,
                                             recursive=apply_to_children)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` (recursive:%s) for user group: `%s` in repo group: `%s`' % (
                     perm.permission_name, apply_to_children,
@@ -2117,7 +2097,7 b' class ApiController(JSONRPCController):'
     # permission check inside
     def revoke_user_group_permission_from_repo_group(
             self, repogroupid, usergroupid,
-            apply_to_children=Optional('none')):
+            apply_to_children='none'):
         """
         Revoke permission for user group on given repository. This command can be
         executed only using api_key belonging to user with admin rights, or
@@ -2159,14 +2139,12 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError(
                     'user group `%s` does not exist' % (usergroupid,))
 
-        apply_to_children = Optional.extract(apply_to_children)
-
         try:
             RepoGroupModel().delete_permission(repo_group=repo_group,
                                                obj=user_group,
                                                obj_type="user_group",
                                                recursive=apply_to_children)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='Revoked perm (recursive:%s) for user group: `%s` in repo group: `%s`' % (
                     apply_to_children, user_group.users_group_name, repo_group.name
@@ -2194,7 +2172,7 b' class ApiController(JSONRPCController):'
                 raise JSONRPCError('gist `%s` does not exist' % (gistid,))
         return gist.get_api_data()
 
-    def get_gists(self, userid=Optional(OAttr('apiuser'))):
+    def get_gists(self, userid=None):
         """
         Get all gists for given user. If userid is empty returned gists
         are for user who called the api
@@ -2205,27 +2183,27 b' class ApiController(JSONRPCController):'
         if not HasPermissionAny('hg.admin')():
             # make sure normal user does not pass someone else userid,
             # he is not allowed to do that
-            if not isinstance(userid, Optional) and userid != request.authuser.user_id:
+            if userid is not None and userid != request.authuser.user_id:
                 raise JSONRPCError(
                     'userid is not the same as your user'
                 )
 
-        if isinstance(userid, Optional):
+        if userid is None:
             user_id = request.authuser.user_id
         else:
             user_id = get_user_or_error(userid).user_id
 
         return [
             gist.get_api_data()
-            for gist in Gist().query()
+            for gist in db.Gist().query()
                 .filter_by(is_expired=False)
-                .filter(Gist.owner_id == user_id)
-                .order_by(Gist.created_on.desc())
+                .filter(db.Gist.owner_id == user_id)
+                .order_by(db.Gist.created_on.desc())
         ]
 
-    def create_gist(self, files, owner=Optional(OAttr('apiuser')),
-                    gist_type=Optional(Gist.GIST_PUBLIC), lifetime=Optional(-1),
-                    description=Optional('')):
+    def create_gist(self, files, owner=None,
+                    gist_type=db.Gist.GIST_PUBLIC, lifetime=-1,
+                    description=''):
 
         """
         Creates new Gist
@@ -2262,13 +2240,10 b' class ApiController(JSONRPCController):'
 
         """
         try:
-            if isinstance(owner, Optional):
+            if owner is None:
                 owner = request.authuser.user_id
 
             owner = get_user_or_error(owner)
-            description = Optional.extract(description)
-            gist_type = Optional.extract(gist_type)
-            lifetime = Optional.extract(lifetime)
 
             gist = GistModel().create(description=description,
                                       owner=owner,
@@ -2276,7 +2251,7 b' class ApiController(JSONRPCController):'
                                       gist_mapping=files,
                                       gist_type=gist_type,
                                       lifetime=lifetime)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='created new gist',
                 gist=gist.get_api_data()
@@ -2285,12 +2260,6 b' class ApiController(JSONRPCController):'
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create gist')
 
-    # def update_gist(self, gistid, files, owner=Optional(OAttr('apiuser')),
-    #                 gist_type=Optional(Gist.GIST_PUBLIC),
-    #                 gist_lifetime=Optional(-1), gist_description=Optional('')):
-    #     gist = get_gist_or_error(gistid)
-    #     updates = {}
-
     # permission check inside
     def delete_gist(self, gistid):
         """
@@ -2324,7 +2293,7 b' class ApiController(JSONRPCController):'
 
         try:
             GistModel().delete(gist)
-            Session().commit()
+            meta.Session().commit()
             return dict(
                 msg='deleted gist ID:%s' % (gist.gist_access_id,),
                 gist=None
@@ -2354,7 +2323,7 b' class ApiController(JSONRPCController):'
             raise JSONRPCError('Repository is empty')
 
     # permission check inside
-    def get_changeset(self, repoid, raw_id, with_reviews=Optional(False)):
+    def get_changeset(self, repoid, raw_id, with_reviews=False):
         repo = get_repo_or_error(repoid)
         if not HasRepoPermissionLevel('read')(repo.repo_name):
             raise JSONRPCError('Access denied to repo %s' % repo.repo_name)
@@ -2364,7 +2333,6 b' class ApiController(JSONRPCController):'
 
         info = dict(changeset.as_dict())
 
-        with_reviews = Optional.extract(with_reviews)
         if with_reviews:
             reviews = ChangesetStatusModel().get_statuses(
                                 repo.repo_name, raw_id)
@@ -2377,7 +2345,7 b' class ApiController(JSONRPCController):'
         """
         Get given pull request by id
         """
-        pull_request = PullRequest.get(pullrequest_id)
+        pull_request = db.PullRequest.get(pullrequest_id)
         if pull_request is None:
             raise JSONRPCError('pull request `%s` does not exist' % (pullrequest_id,))
         if not HasRepoPermissionLevel('read')(pull_request.org_repo.repo_name):
@@ -2390,7 +2358,7 b' class ApiController(JSONRPCController):'
         Add comment, close and change status of pull request.
         """
         apiuser = get_user_or_error(request.authuser.user_id)
-        pull_request = PullRequest.get(pull_request_id)
+        pull_request = db.PullRequest.get(pull_request_id)
         if pull_request is None:
             raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))
         if (not HasRepoPermissionLevel('read')(pull_request.org_repo.repo_name)):
@@ -2412,10 +2380,10 b' class ApiController(JSONRPCController):'
             pull_request=pull_request.pull_request_id,
             f_path=None,
             line_no=None,
-            status_change=ChangesetStatus.get_status_lbl(status),
+            status_change=db.ChangesetStatus.get_status_lbl(status),
             closing_pr=close_pr
         )
-        action_logger(apiuser,
+        userlog.action_logger(apiuser,
                       'user_commented_pull_request:%s' % pull_request_id,
                       pull_request.org_repo, request.ip_addr)
         if status:
@@ -2428,8 +2396,54 b' class ApiController(JSONRPCController):'
             )
         if close_pr:
             PullRequestModel().close_pull_request(pull_request_id)
-            action_logger(apiuser,
+            userlog.action_logger(apiuser,
                           'user_closed_pull_request:%s' % pull_request_id,
                           pull_request.org_repo, request.ip_addr)
-        Session().commit()
+        meta.Session().commit()
         return True
+
+    # permission check inside
+    def edit_reviewers(self, pull_request_id, add=None, remove=None):
+        """
+        Add and/or remove one or more reviewers to a pull request, by username
+        or user ID. Reviewers are specified either as a single-user string or
+        as a JSON list of one or more strings.
+        """
+        if add is None and remove is None:
+            raise JSONRPCError('''Invalid request. Neither 'add' nor 'remove' is specified.''')
+
+        pull_request = db.PullRequest.get(pull_request_id)
+        if pull_request is None:
+            raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))
+
+        apiuser = get_user_or_error(request.authuser.user_id)
+        is_owner = apiuser.user_id == pull_request.owner_id
+        is_repo_admin = HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)
+        if not (apiuser.admin or is_repo_admin or is_owner):
+            raise JSONRPCError('No permission to edit reviewers of this pull request. User needs to be admin or pull request owner.')
+        if pull_request.is_closed():
+            raise JSONRPCError('Cannot edit reviewers of a closed pull request.')
+
+        if not isinstance(add, list):
+            add = [add]
+        if not isinstance(remove, list):
+            remove = [remove]
+
+        # look up actual user objects from given name or id. Bail out if unknown.
+        add_objs = set(get_user_or_error(user) for user in add if user is not None)
+        remove_objs = set(get_user_or_error(user) for user in remove if user is not None)
+
+        new_reviewers = redundant_reviewers = set()
+        if add_objs:
+            new_reviewers, redundant_reviewers = PullRequestModel().add_reviewers(apiuser, pull_request, add_objs)
+        if remove_objs:
+            PullRequestModel().remove_reviewers(apiuser, pull_request, remove_objs)
+
+        meta.Session().commit()
+
+        return {
+            'added': [x.username for x in new_reviewers],
+            'already_present': [x.username for x in redundant_reviewers],
+            # NOTE: no explicit check that removed reviewers were actually present.
+            'removed': [x.username for x in remove_objs],
+        }

kallithea/controllers/base.py

@@ -13,8 +13,8 b''
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-kallithea.lib.base
-~~~~~~~~~~~~~~~~~~
+kallithea.controllers.base
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The base Controller API
 Provides the BaseController class for subclassing. And usage in different
@@ -43,16 +43,15 b' from tg import TGController, config, ren'
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
 
-from kallithea import BACKENDS, __version__
-from kallithea.config.routing import url
-from kallithea.lib import auth_modules, ext_json
+import kallithea
+from kallithea.lib import auth_modules, ext_json, webutils
 from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware
 from kallithea.lib.exceptions import UserCreationError
 from kallithea.lib.utils import get_repo_slug, is_valid_repo
-from kallithea.lib.utils2 import AttributeDict, ascii_bytes, safe_int, safe_str, set_hook_environment, str2bool
+from kallithea.lib.utils2 import AttributeDict, asbool, ascii_bytes, safe_int, safe_str, set_hook_environment
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError
-from kallithea.model import meta
-from kallithea.model.db import PullRequest, Repository, Setting, User
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.scm import ScmModel
 
 
@@ -65,35 +64,29 b' def render(template_path):'
 
 def _filter_proxy(ip):
     """
-    HEADERS can have multiple ips inside the left-most being the original
-    client, and each successive proxy that passed the request adding the IP
-    address where it received the request from.
+    HTTP_X_FORWARDED_FOR headers can have multiple IP addresses, with the
+    leftmost being the original client. Each proxy that is forwarding the
+    request will usually add the IP address it sees the request coming from.
 
-    :param ip:
+    The client might have provided a fake leftmost value before hitting the
+    first proxy, so if we have a proxy that is adding one IP address, we can
+    only trust the rightmost address.
     """
     if ',' in ip:
         _ips = ip.split(',')
-        _first_ip = _ips[0].strip()
+        _first_ip = _ips[-1].strip()
         log.debug('Got multiple IPs %s, using %s', ','.join(_ips), _first_ip)
         return _first_ip
     return ip
 
 
-def _get_ip_addr(environ):
-    proxy_key = 'HTTP_X_REAL_IP'
-    proxy_key2 = 'HTTP_X_FORWARDED_FOR'
-    def_key = 'REMOTE_ADDR'
-
-    ip = environ.get(proxy_key)
-    if ip:
-        return _filter_proxy(ip)
-
-    ip = environ.get(proxy_key2)
-    if ip:
-        return _filter_proxy(ip)
-
-    ip = environ.get(def_key, '0.0.0.0')
-    return _filter_proxy(ip)
+def get_ip_addr(environ):
+    """The web server will set REMOTE_ADDR to the unfakeable IP layer client IP address.
+    If using a proxy server, make it possible to use another value, such as
+    the X-Forwarded-For header, by setting `remote_addr_variable = HTTP_X_FORWARDED_FOR`.
+    """
+    remote_addr_variable = kallithea.CONFIG.get('remote_addr_variable', 'REMOTE_ADDR')
+    return _filter_proxy(environ.get(remote_addr_variable, '0.0.0.0'))
 
 
 def get_path_info(environ):
@@ -223,7 +216,7 b' class BaseVCSController(object):'
         Returns (None, wsgi_app) to send the wsgi_app response to the client.
         """
         # Use anonymous access if allowed for action on repo.
-        default_user = User.get_default_user()
+        default_user = db.User.get_default_user()
         default_authuser = AuthUser.make(dbuser=default_user, ip_addr=ip_addr)
         if default_authuser is None:
             log.debug('No anonymous access at all') # move on to proper user auth
@@ -260,7 +253,7 b' class BaseVCSController(object):'
         # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
         #==============================================================
         try:
-            user = User.get_by_username_or_email(username)
+            user = db.User.get_by_username_or_email(username)
         except Exception:
             log.error(traceback.format_exc())
             return None, webob.exc.HTTPInternalServerError()
@@ -301,9 +294,6 b' class BaseVCSController(object):'
 
         return True
 
-    def _get_ip_addr(self, environ):
-        return _get_ip_addr(environ)
-
     def __call__(self, environ, start_response):
         try:
             # try parsing a request for this VCS - if it fails, call the wrapped app
@@ -325,7 +315,7 b' class BaseVCSController(object):'
             #======================================================================
             # CHECK PERMISSIONS
             #======================================================================
-            ip_addr = self._get_ip_addr(environ)
+            ip_addr = get_ip_addr(environ)
             user, response_app = self._authorize(environ, parsed_request.action, parsed_request.repo_name, ip_addr)
             if response_app is not None:
                 return response_app(environ, start_response)
@@ -362,30 +352,29 b' class BaseController(TGController):'
             # guaranteed to be side effect free. In practice, the only situation
             # where we allow side effects without ambient authority is when the
             # authority comes from an API key; and that is handled above.
-            from kallithea.lib import helpers as h
-            token = request.POST.get(h.session_csrf_secret_name)
-            if not token or token != h.session_csrf_secret_token():
+            token = request.POST.get(webutils.session_csrf_secret_name)
+            if not token or token != webutils.session_csrf_secret_token():
                 log.error('CSRF check failed')
                 raise webob.exc.HTTPForbidden()
 
-        c.kallithea_version = __version__
-        rc_config = Setting.get_app_settings()
+        c.kallithea_version = kallithea.__version__
+        settings = db.Setting.get_app_settings()
 
         # Visual options
         c.visual = AttributeDict({})
 
         ## DB stored
-        c.visual.show_public_icon = str2bool(rc_config.get('show_public_icon'))
-        c.visual.show_private_icon = str2bool(rc_config.get('show_private_icon'))
-        c.visual.stylify_metalabels = str2bool(rc_config.get('stylify_metalabels'))
-        c.visual.page_size = safe_int(rc_config.get('dashboard_items', 100))
-        c.visual.admin_grid_items = safe_int(rc_config.get('admin_grid_items', 100))
-        c.visual.repository_fields = str2bool(rc_config.get('repository_fields'))
-        c.visual.show_version = str2bool(rc_config.get('show_version'))
-        c.visual.use_gravatar = str2bool(rc_config.get('use_gravatar'))
-        c.visual.gravatar_url = rc_config.get('gravatar_url')
+        c.visual.show_public_icon = asbool(settings.get('show_public_icon'))
+        c.visual.show_private_icon = asbool(settings.get('show_private_icon'))
+        c.visual.stylify_metalabels = asbool(settings.get('stylify_metalabels'))
+        c.visual.page_size = safe_int(settings.get('dashboard_items', 100))
+        c.visual.admin_grid_items = safe_int(settings.get('admin_grid_items', 100))
+        c.visual.repository_fields = asbool(settings.get('repository_fields'))
+        c.visual.show_version = asbool(settings.get('show_version'))
+        c.visual.use_gravatar = asbool(settings.get('use_gravatar'))
+        c.visual.gravatar_url = settings.get('gravatar_url')
 
-        c.ga_code = rc_config.get('ga_code')
+        c.ga_code = settings.get('ga_code')
         # TODO: replace undocumented backwards compatibility hack with db upgrade and rename ga_code
         if c.ga_code and '<' not in c.ga_code:
             c.ga_code = '''<script type="text/javascript">
@@ -399,25 +388,25 b' class BaseController(TGController):'
                     var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
                     })();
             </script>''' % c.ga_code
-        c.site_name = rc_config.get('title')
-        c.clone_uri_tmpl = rc_config.get('clone_uri_tmpl') or Repository.DEFAULT_CLONE_URI
-        c.clone_ssh_tmpl = rc_config.get('clone_ssh_tmpl') or Repository.DEFAULT_CLONE_SSH
+        c.site_name = settings.get('title')
+        c.clone_uri_tmpl = settings.get('clone_uri_tmpl') or db.Repository.DEFAULT_CLONE_URI
+        c.clone_ssh_tmpl = settings.get('clone_ssh_tmpl') or db.Repository.DEFAULT_CLONE_SSH
 
         ## INI stored
-        c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))
-        c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))
-        c.ssh_enabled = str2bool(config.get('ssh_enabled', False))
+        c.visual.allow_repo_location_change = asbool(config.get('allow_repo_location_change', True))
+        c.visual.allow_custom_hooks_settings = asbool(config.get('allow_custom_hooks_settings', True))
+        c.ssh_enabled = asbool(config.get('ssh_enabled', False))
 
         c.instance_id = config.get('instance_id')
         c.issues_url = config.get('bugtracker', url('issues_url'))
         # END CONFIG VARS
 
         c.repo_name = get_repo_slug(request)  # can be empty
-        c.backends = list(BACKENDS)
+        c.backends = list(kallithea.BACKENDS)
 
         self.cut_off_limit = safe_int(config.get('cut_off_limit'))
 
-        c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()
+        c.my_pr_count = db.PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()
 
         self.scm_model = ScmModel()
 
@@ -445,16 +434,15 b' class BaseController(TGController):'
             try:
                 user_info = auth_modules.authenticate('', '', request.environ)
             except UserCreationError as e:
-                from kallithea.lib import helpers as h
-                h.flash(e, 'error', logf=log.error)
+                webutils.flash(e, 'error', logf=log.error)
             else:
                 if user_info is not None:
                     username = user_info['username']
-                    user = User.get_by_username(username, case_insensitive=True)
+                    user = db.User.get_by_username(username, case_insensitive=True)
                     return log_in_user(user, remember=False, is_external_auth=True, ip_addr=ip_addr)
 
         # User is default user (if active) or anonymous
-        default_user = User.get_default_user()
+        default_user = db.User.get_default_user()
         authuser = AuthUser.make(dbuser=default_user, ip_addr=ip_addr)
         if authuser is None: # fall back to anonymous
             authuser = AuthUser(dbuser=default_user) # TODO: somehow use .make?
@@ -475,12 +463,11 b' class BaseController(TGController):'
             raise webob.exc.HTTPMethodNotAllowed()
 
         # Make sure CSRF token never appears in the URL. If so, invalidate it.
-        from kallithea.lib import helpers as h
-        if h.session_csrf_secret_name in request.GET:
+        if webutils.session_csrf_secret_name in request.GET:
             log.error('CSRF key leak detected')
-            session.pop(h.session_csrf_secret_name, None)
+            session.pop(webutils.session_csrf_secret_name, None)
             session.save()
-            h.flash(_('CSRF token leak has been detected - all form tokens have been expired'),
+            webutils.flash(_('CSRF token leak has been detected - all form tokens have been expired'),
                     category='error')
 
         # WebOb already ignores request payload parameters for anything other
@@ -492,7 +479,7 b' class BaseController(TGController):'
 
     def __call__(self, environ, context):
         try:
-            ip_addr = _get_ip_addr(environ)
+            ip_addr = get_ip_addr(environ)
             self._basic_security_checks()
 
             api_key = request.GET.get('api_key')
@@ -513,7 +500,7 b' class BaseController(TGController):'
                 needs_csrf_check = request.method not in ['GET', 'HEAD']
 
             else:
-                dbuser = User.get_by_api_key(api_key)
+                dbuser = db.User.get_by_api_key(api_key)
                 if dbuser is None:
                     log.info('No db user found for authentication with API key ****%s from %s',
                              api_key[-4:], ip_addr)
@@ -553,7 +540,7 b' class BaseRepoController(BaseController)'
     def _before(self, *args, **kwargs):
         super(BaseRepoController, self)._before(*args, **kwargs)
         if c.repo_name:  # extracted from request by base-base BaseController._before
-            _dbr = Repository.get_by_repo_name(c.repo_name)
+            _dbr = db.Repository.get_by_repo_name(c.repo_name)
             if not _dbr:
                 return
 
@@ -565,7 +552,7 b' class BaseRepoController(BaseController)'
             if route in ['delete_repo']:
                 return
 
-            if _dbr.repo_state in [Repository.STATE_PENDING]:
+            if _dbr.repo_state in [db.Repository.STATE_PENDING]:
                 if route in ['repo_creating_home']:
                     return
                 check_url = url('repo_creating_home', repo_name=c.repo_name)
@@ -576,8 +563,7 b' class BaseRepoController(BaseController)'
             if c.db_repo_scm_instance is None:
                 log.error('%s this repository is present in database but it '
                           'cannot be created as an scm instance', c.repo_name)
-                from kallithea.lib import helpers as h
-                h.flash(_('Repository not found in the filesystem'),
+                webutils.flash(_('Repository not found in the filesystem'),
                         category='error')
                 raise webob.exc.HTTPNotFound()
 
@@ -593,22 +579,21 b' class BaseRepoController(BaseController)'
         """
         Safe way to get changeset. If error occurs show error.
         """
-        from kallithea.lib import helpers as h
         try:
             return repo.scm_instance.get_ref_revision(ref_type, ref_name)
         except EmptyRepositoryError as e:
             if returnempty:
                 return repo.scm_instance.EMPTY_CHANGESET
-            h.flash(_('There are no changesets yet'), category='error')
+            webutils.flash(_('There are no changesets yet'), category='error')
             raise webob.exc.HTTPNotFound()
         except ChangesetDoesNotExistError as e:
-            h.flash(_('Changeset for %s %s not found in %s') %
+            webutils.flash(_('Changeset for %s %s not found in %s') %
                               (ref_type, ref_name, repo.repo_name),
                     category='error')
             raise webob.exc.HTTPNotFound()
         except RepositoryError as e:
             log.error(traceback.format_exc())
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
             raise webob.exc.HTTPBadRequest()
 
 
@@ -643,7 +628,6 b' def IfSshEnabled(func, *args, **kwargs):'
     If SSH access is disabled in the configuration file, HTTPNotFound is raised.
     """
     if not c.ssh_enabled:
-        from kallithea.lib import helpers as h
-        h.flash(_("SSH access is disabled."), category='warning')
+        webutils.flash(_("SSH access is disabled."), category='warning')
         raise webob.exc.HTTPNotFound()
     return func(*args, **kwargs)

kallithea/controllers/changelog.py

@@ -33,20 +33,20 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound
 
-import kallithea.lib.helpers as h
-from kallithea.config.routing import url
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, render
 from kallithea.lib.graphmod import graph_data
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, NodeDoesNotExistError, RepositoryError
+from kallithea.lib.webutils import url
 
 
 log = logging.getLogger(__name__)
 
 
-class ChangelogController(BaseRepoController):
+class ChangelogController(base.BaseRepoController):
 
     def _before(self, *args, **kwargs):
         super(ChangelogController, self)._before(*args, **kwargs)
@@ -64,10 +64,10 b' class ChangelogController(BaseRepoContro'
         try:
             return c.db_repo_scm_instance.get_changeset(rev)
         except EmptyRepositoryError as e:
-            h.flash(_('There are no changesets yet'), category='error')
+            webutils.flash(_('There are no changesets yet'), category='error')
         except RepositoryError as e:
             log.error(traceback.format_exc())
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
         raise HTTPBadRequest()
 
     @LoginRequired(allow_default_user=True)
@@ -111,8 +111,8 b' class ChangelogController(BaseRepoContro'
                         cs = self.__get_cs(revision, repo_name)
                         collection = cs.get_file_history(f_path)
                     except RepositoryError as e:
-                        h.flash(e, category='warning')
-                        raise HTTPFound(location=h.url('changelog_home', repo_name=repo_name))
+                        webutils.flash(e, category='warning')
+                        raise HTTPFound(location=webutils.url('changelog_home', repo_name=repo_name))
             else:
                 collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,
                                                         branch_name=branch_name, reverse=True)
@@ -125,11 +125,11 b' class ChangelogController(BaseRepoContro'
             c.cs_comments = c.db_repo.get_comments(page_revisions)
             c.cs_statuses = c.db_repo.statuses(page_revisions)
         except EmptyRepositoryError as e:
-            h.flash(e, category='warning')
+            webutils.flash(e, category='warning')
             raise HTTPFound(location=url('summary_home', repo_name=c.repo_name))
         except (RepositoryError, ChangesetDoesNotExistError, Exception) as e:
             log.error(traceback.format_exc())
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
             raise HTTPFound(location=url('changelog_home', repo_name=c.repo_name))
 
         c.branch_name = branch_name
@@ -146,12 +146,12 b' class ChangelogController(BaseRepoContro'
 
         c.revision = revision # requested revision ref
         c.first_revision = c.cs_pagination[0] # pagination is never empty here!
-        return render('changelog/changelog.html')
+        return base.render('changelog/changelog.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
     def changelog_details(self, cs):
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             c.cs = c.db_repo_scm_instance.get_changeset(cs)
-            return render('changelog/changelog_details.html')
+            return base.render('changelog/changelog_details.html')
         raise HTTPNotFound()

kallithea/controllers/changeset.py

@@ -28,7 +28,7 b' Original author and date, and relevant c'
 import binascii
 import logging
 import traceback
-from collections import OrderedDict, defaultdict
+from collections import OrderedDict
 
 from tg import request, response
 from tg import tmpl_context as c
@@ -36,136 +36,22 b' from tg.i18n import ugettext as _'
 from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPNotFound
 
 import kallithea.lib.helpers as h
-from kallithea.lib import diffs
+from kallithea.controllers import base
+from kallithea.lib import auth, diffs, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, jsonify, render
 from kallithea.lib.graphmod import graph_data
-from kallithea.lib.utils import action_logger
 from kallithea.lib.utils2 import ascii_str, safe_str
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError
+from kallithea.model import db, meta, userlog
 from kallithea.model.changeset_status import ChangesetStatusModel
 from kallithea.model.comment import ChangesetCommentsModel
-from kallithea.model.db import ChangesetComment, ChangesetStatus
-from kallithea.model.meta import Session
 from kallithea.model.pull_request import PullRequestModel
 
 
 log = logging.getLogger(__name__)
 
 
-def _update_with_GET(params, GET):
-    for k in ['diff1', 'diff2', 'diff']:
-        params[k] += GET.getall(k)
-
-
-def anchor_url(revision, path, GET):
-    fid = h.FID(revision, path)
-    return h.url.current(anchor=fid, **dict(GET))
-
-
-def get_ignore_ws(fid, GET):
-    ig_ws_global = GET.get('ignorews')
-    ig_ws = [k for k in GET.getall(fid) if k.startswith('WS')]
-    if ig_ws:
-        try:
-            return int(ig_ws[0].split(':')[-1])
-        except ValueError:
-            raise HTTPBadRequest()
-    return ig_ws_global
-
-
-def _ignorews_url(GET, fileid=None):
-    fileid = str(fileid) if fileid else None
-    params = defaultdict(list)
-    _update_with_GET(params, GET)
-    lbl = _('Show whitespace')
-    ig_ws = get_ignore_ws(fileid, GET)
-    ln_ctx = get_line_ctx(fileid, GET)
-    # global option
-    if fileid is None:
-        if ig_ws is None:
-            params['ignorews'] += [1]
-            lbl = _('Ignore whitespace')
-        ctx_key = 'context'
-        ctx_val = ln_ctx
-    # per file options
-    else:
-        if ig_ws is None:
-            params[fileid] += ['WS:1']
-            lbl = _('Ignore whitespace')
-
-        ctx_key = fileid
-        ctx_val = 'C:%s' % ln_ctx
-    # if we have passed in ln_ctx pass it along to our params
-    if ln_ctx:
-        params[ctx_key] += [ctx_val]
-
-    params['anchor'] = fileid
-    icon = h.literal('<i class="icon-strike"></i>')
-    return h.link_to(icon, h.url.current(**params), title=lbl, **{'data-toggle': 'tooltip'})
-
-
-def get_line_ctx(fid, GET):
-    ln_ctx_global = GET.get('context')
-    if fid:
-        ln_ctx = [k for k in GET.getall(fid) if k.startswith('C')]
-    else:
-        _ln_ctx = [k for k in GET if k.startswith('C')]
-        ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx else ln_ctx_global
-        if ln_ctx:
-            ln_ctx = [ln_ctx]
-
-    if ln_ctx:
-        retval = ln_ctx[0].split(':')[-1]
-    else:
-        retval = ln_ctx_global
-
-    try:
-        return int(retval)
-    except Exception:
-        return 3
-
-
-def _context_url(GET, fileid=None):
-    """
-    Generates url for context lines
-
-    :param fileid:
-    """
-
-    fileid = str(fileid) if fileid else None
-    ig_ws = get_ignore_ws(fileid, GET)
-    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2
-
-    params = defaultdict(list)
-    _update_with_GET(params, GET)
-
-    # global option
-    if fileid is None:
-        if ln_ctx > 0:
-            params['context'] += [ln_ctx]
-
-        if ig_ws:
-            ig_ws_key = 'ignorews'
-            ig_ws_val = 1
-
-    # per file option
-    else:
-        params[fileid] += ['C:%s' % ln_ctx]
-        ig_ws_key = fileid
-        ig_ws_val = 'WS:%s' % 1
-
-    if ig_ws:
-        params[ig_ws_key] += [ig_ws_val]
-
-    lbl = _('Increase diff context to %(num)s lines') % {'num': ln_ctx}
-
-    params['anchor'] = fileid
-    icon = h.literal('<i class="icon-sort"></i>')
-    return h.link_to(icon, h.url.current(**params), title=lbl, **{'data-toggle': 'tooltip'})
-
-
 def create_cs_pr_comment(repo_name, revision=None, pull_request=None, allowed_to_change_status=True):
     """
     Add a comment to the specified changeset or pull request, using POST values
@@ -199,21 +85,21 b' def create_cs_pr_comment(repo_name, revi'
 
     if not allowed_to_change_status:
         if status or close_pr:
-            h.flash(_('No permission to change status'), 'error')
+            webutils.flash(_('No permission to change status'), 'error')
             raise HTTPForbidden()
 
     if pull_request and delete == "delete":
         if (pull_request.owner_id == request.authuser.user_id or
-            h.HasPermissionAny('hg.admin')() or
-            h.HasRepoPermissionLevel('admin')(pull_request.org_repo.repo_name) or
-            h.HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)
+            auth.HasPermissionAny('hg.admin')() or
+            auth.HasRepoPermissionLevel('admin')(pull_request.org_repo.repo_name) or
+            auth.HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)
         ) and not pull_request.is_closed():
             PullRequestModel().delete(pull_request)
-            Session().commit()
-            h.flash(_('Successfully deleted pull request %s') % pull_request_id,
+            meta.Session().commit()
+            webutils.flash(_('Successfully deleted pull request %s') % pull_request_id,
                     category='success')
             return {
-               'location': h.url('my_pullrequests'), # or repo pr list?
+               'location': webutils.url('my_pullrequests'), # or repo pr list?
             }
         raise HTTPForbidden()
 
@@ -227,7 +113,7 b' def create_cs_pr_comment(repo_name, revi'
         pull_request=pull_request_id,
         f_path=f_path or None,
         line_no=line_no or None,
-        status_change=ChangesetStatus.get_status_lbl(status) if status else None,
+        status_change=db.ChangesetStatus.get_status_lbl(status) if status else None,
         closing_pr=close_pr,
     )
 
@@ -245,30 +131,30 b' def create_cs_pr_comment(repo_name, revi'
         action = 'user_commented_pull_request:%s' % pull_request_id
     else:
         action = 'user_commented_revision:%s' % revision
-    action_logger(request.authuser, action, c.db_repo, request.ip_addr)
+    userlog.action_logger(request.authuser, action, c.db_repo, request.ip_addr)
 
     if pull_request and close_pr:
         PullRequestModel().close_pull_request(pull_request_id)
-        action_logger(request.authuser,
+        userlog.action_logger(request.authuser,
                       'user_closed_pull_request:%s' % pull_request_id,
                       c.db_repo, request.ip_addr)
 
-    Session().commit()
+    meta.Session().commit()
 
     data = {
-       'target_id': h.safeid(request.POST.get('f_path')),
+       'target_id': webutils.safeid(request.POST.get('f_path')),
     }
     if comment is not None:
         c.comment = comment
         data.update(comment.get_dict())
         data.update({'rendered_text':
-                     render('changeset/changeset_comment_block.html')})
+                     base.render('changeset/changeset_comment_block.html')})
 
     return data
 
 def delete_cs_pr_comment(repo_name, comment_id):
     """Delete a comment from a changeset or pull request"""
-    co = ChangesetComment.get_or_404(comment_id)
+    co = db.ChangesetComment.get_or_404(comment_id)
     if co.repo.repo_name != repo_name:
         raise HTTPNotFound()
     if co.pull_request and co.pull_request.is_closed():
@@ -276,15 +162,15 b' def delete_cs_pr_comment(repo_name, comm'
         raise HTTPForbidden()
 
     owner = co.author_id == request.authuser.user_id
-    repo_admin = h.HasRepoPermissionLevel('admin')(repo_name)
-    if h.HasPermissionAny('hg.admin')() or repo_admin or owner:
+    repo_admin = auth.HasRepoPermissionLevel('admin')(repo_name)
+    if auth.HasPermissionAny('hg.admin')() or repo_admin or owner:
         ChangesetCommentsModel().delete(comment=co)
-        Session().commit()
+        meta.Session().commit()
         return True
     else:
         raise HTTPForbidden()
 
-class ChangesetController(BaseRepoController):
+class ChangesetController(base.BaseRepoController):
 
     def _before(self, *args, **kwargs):
         super(ChangesetController, self)._before(*args, **kwargs)
@@ -292,17 +178,12 b' class ChangesetController(BaseRepoContro'
 
     def _index(self, revision, method):
         c.pull_request = None
-        c.anchor_url = anchor_url
-        c.ignorews_url = _ignorews_url
-        c.context_url = _context_url
         c.fulldiff = request.GET.get('fulldiff') # for reporting number of changed files
         # get ranges of revisions if preset
         rev_range = revision.split('...')[:2]
-        enable_comments = True
         c.cs_repo = c.db_repo
         try:
             if len(rev_range) == 2:
-                enable_comments = False
                 rev_start = rev_range[0]
                 rev_end = rev_range[1]
                 rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,
@@ -317,7 +198,7 b' class ChangesetController(BaseRepoContro'
         except (ChangesetDoesNotExistError, EmptyRepositoryError):
             log.debug(traceback.format_exc())
             msg = _('Such revision does not exist for this repository')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPNotFound()
 
         c.changes = OrderedDict()
@@ -325,7 +206,7 b' class ChangesetController(BaseRepoContro'
         c.lines_added = 0  # count of lines added
         c.lines_deleted = 0  # count of lines removes
 
-        c.changeset_statuses = ChangesetStatus.STATUSES
+        c.changeset_statuses = db.ChangesetStatus.STATUSES
         comments = dict()
         c.statuses = []
         c.inline_comments = []
@@ -357,11 +238,10 b' class ChangesetController(BaseRepoContro'
 
             cs2 = changeset.raw_id
             cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id
-            context_lcl = get_line_ctx('', request.GET)
-            ign_whitespace_lcl = get_ignore_ws('', request.GET)
-
+            ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)
+            diff_context_size = h.get_diff_context_size(request.GET)
             raw_diff = diffs.get_diff(c.db_repo_scm_instance, cs1, cs2,
-                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)
+                ignore_whitespace=ignore_whitespace_diff, context=diff_context_size)
             diff_limit = None if c.fulldiff else self.cut_off_limit
             file_diff_data = []
             if method == 'show':
@@ -376,7 +256,7 b' class ChangesetController(BaseRepoContro'
                     filename = f['filename']
                     fid = h.FID(changeset.raw_id, filename)
                     url_fid = h.FID('', filename)
-                    html_diff = diffs.as_html(enable_comments=enable_comments, parsed_lines=[f])
+                    html_diff = diffs.as_html(parsed_lines=[f])
                     file_diff_data.append((fid, url_fid, f['operation'], f['old_filename'], filename, html_diff, st))
             else:
                 # downloads/raw we only need RAW diff nothing else
@@ -405,19 +285,19 b' class ChangesetController(BaseRepoContro'
         elif method == 'patch':
             response.content_type = 'text/plain'
             c.diff = safe_str(raw_diff)
-            return render('changeset/patch_changeset.html')
+            return base.render('changeset/patch_changeset.html')
         elif method == 'raw':
             response.content_type = 'text/plain'
             return raw_diff
         elif method == 'show':
             if len(c.cs_ranges) == 1:
-                return render('changeset/changeset.html')
+                return base.render('changeset/changeset.html')
             else:
                 c.cs_ranges_org = None
                 c.cs_comments = {}
                 revs = [ctx.revision for ctx in reversed(c.cs_ranges)]
                 c.jsdata = graph_data(c.db_repo_scm_instance, revs)
-                return render('changeset/changeset_range.html')
+                return base.render('changeset/changeset_range.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -441,19 +321,19 b' class ChangesetController(BaseRepoContro'
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def comment(self, repo_name, revision):
         return create_cs_pr_comment(repo_name, revision=revision)
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def delete_comment(self, repo_name, comment_id):
         return delete_cs_pr_comment(repo_name, comment_id)
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def changeset_info(self, repo_name, revision):
         if request.is_xhr:
             try:
@@ -465,7 +345,7 b' class ChangesetController(BaseRepoContro'
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def changeset_children(self, repo_name, revision):
         if request.is_xhr:
             changeset = c.db_repo_scm_instance.get_changeset(revision)
@@ -478,7 +358,7 b' class ChangesetController(BaseRepoContro'
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def changeset_parents(self, repo_name, revision):
         if request.is_xhr:
             changeset = c.db_repo_scm_instance.get_changeset(revision)

kallithea/controllers/compare.py

@@ -28,29 +28,25 b' Original author and date, and relevant c'
 
 
 import logging
-import re
 
-import mercurial.unionrepo
 from tg import request
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound
 
-from kallithea.config.routing import url
-from kallithea.controllers.changeset import _context_url, _ignorews_url
-from kallithea.lib import diffs
-from kallithea.lib import helpers as h
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.lib import diffs, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, render
 from kallithea.lib.graphmod import graph_data
-from kallithea.lib.utils2 import ascii_bytes, ascii_str, safe_bytes, safe_int
-from kallithea.model.db import Repository
+from kallithea.lib.webutils import url
+from kallithea.model import db
 
 
 log = logging.getLogger(__name__)
 
 
-class CompareController(BaseRepoController):
+class CompareController(base.BaseRepoController):
 
     def _before(self, *args, **kwargs):
         super(CompareController, self)._before(*args, **kwargs)
@@ -63,122 +59,24 b' class CompareController(BaseRepoControll'
         if other_repo is None:
             c.cs_repo = c.a_repo
         else:
-            c.cs_repo = Repository.get_by_repo_name(other_repo)
+            c.cs_repo = db.Repository.get_by_repo_name(other_repo)
             if c.cs_repo is None:
                 msg = _('Could not find other repository %s') % other_repo
-                h.flash(msg, category='error')
+                webutils.flash(msg, category='error')
                 raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))
 
         # Verify that it's even possible to compare these two repositories.
         if c.a_repo.scm_instance.alias != c.cs_repo.scm_instance.alias:
             msg = _('Cannot compare repositories of different types')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))
 
-    @staticmethod
-    def _get_changesets(alias, org_repo, org_rev, other_repo, other_rev):
-        """
-        Returns lists of changesets that can be merged from org_repo@org_rev
-        to other_repo@other_rev
-        ... and the other way
-        ... and the ancestors that would be used for merge
-
-        :param org_repo: repo object, that is most likely the original repo we forked from
-        :param org_rev: the revision we want our compare to be made
-        :param other_repo: repo object, most likely the fork of org_repo. It has
-            all changesets that we need to obtain
-        :param other_rev: revision we want out compare to be made on other_repo
-        """
-        ancestors = None
-        if org_rev == other_rev:
-            org_changesets = []
-            other_changesets = []
-
-        elif alias == 'hg':
-            # case two independent repos
-            if org_repo != other_repo:
-                hgrepo = mercurial.unionrepo.makeunionrepository(other_repo.baseui,
-                                                       safe_bytes(other_repo.path),
-                                                       safe_bytes(org_repo.path))
-                # all ancestors of other_rev will be in other_repo and
-                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot
-
-            # no remote compare do it on the same repository
-            else:
-                hgrepo = other_repo._repo
-
-            ancestors = [ascii_str(hgrepo[ancestor].hex()) for ancestor in
-                         hgrepo.revs(b"id(%s) & ::id(%s)", ascii_bytes(other_rev), ascii_bytes(org_rev))]
-            if ancestors:
-                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)
-            else:
-                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)
-                ancestors = [ascii_str(hgrepo[ancestor].hex()) for ancestor in
-                             hgrepo.revs(b"heads(::id(%s) & ::id(%s))", ascii_bytes(org_rev), ascii_bytes(other_rev))] # FIXME: expensive!
-
-            other_changesets = [
-                other_repo.get_changeset(rev)
-                for rev in hgrepo.revs(
-                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",
-                    ascii_bytes(other_rev), ascii_bytes(org_rev), ascii_bytes(org_rev))
-            ]
-            org_changesets = [
-                org_repo.get_changeset(ascii_str(hgrepo[rev].hex()))
-                for rev in hgrepo.revs(
-                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",
-                    ascii_bytes(org_rev), ascii_bytes(other_rev), ascii_bytes(other_rev))
-            ]
-
-        elif alias == 'git':
-            if org_repo != other_repo:
-                from dulwich.repo import Repo
-                from dulwich.client import SubprocessGitClient
-
-                gitrepo = Repo(org_repo.path)
-                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)
-
-                gitrepo_remote = Repo(other_repo.path)
-                SubprocessGitClient(thin_packs=False).fetch(org_repo.path, gitrepo_remote)
-
-                revs = [
-                    ascii_str(x.commit.id)
-                    for x in gitrepo_remote.get_walker(include=[ascii_bytes(other_rev)],
-                                                       exclude=[ascii_bytes(org_rev)])
-                ]
-                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]
-                if other_changesets:
-                    ancestors = [other_changesets[0].parents[0].raw_id]
-                else:
-                    # no changesets from other repo, ancestor is the other_rev
-                    ancestors = [other_rev]
-
-                gitrepo.close()
-                gitrepo_remote.close()
-
-            else:
-                so = org_repo.run_git_command(
-                    ['log', '--reverse', '--pretty=format:%H',
-                     '-s', '%s..%s' % (org_rev, other_rev)]
-                )
-                other_changesets = [org_repo.get_changeset(cs)
-                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]
-                so = org_repo.run_git_command(
-                    ['merge-base', org_rev, other_rev]
-                )
-                ancestors = [re.findall(r'[0-9a-fA-F]{40}', so)[0]]
-            org_changesets = []
-
-        else:
-            raise Exception('Bad alias only git and hg is allowed')
-
-        return other_changesets, org_changesets, ancestors
-
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
     def index(self, repo_name):
         c.compare_home = True
         c.a_ref_name = c.cs_ref_name = None
-        return render('compare/compare_diff.html')
+        return base.render('compare/compare_diff.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -202,18 +100,14 b' class CompareController(BaseRepoControll'
         # is_ajax_preview puts hidden input field with changeset revisions
         c.is_ajax_preview = partial and request.GET.get('is_ajax_preview')
         # swap url for compare_diff page - never partial and never is_ajax_preview
-        c.swap_url = h.url('compare_url',
+        c.swap_url = webutils.url('compare_url',
             repo_name=c.cs_repo.repo_name,
             org_ref_type=other_ref_type, org_ref_name=other_ref_name,
             other_repo=c.a_repo.repo_name,
             other_ref_type=org_ref_type, other_ref_name=org_ref_name,
             merge=merge or '')
-
-        # set callbacks for generating markup for icons
-        c.ignorews_url = _ignorews_url
-        c.context_url = _context_url
-        ignore_whitespace = request.GET.get('ignorews') == '1'
-        line_context = safe_int(request.GET.get('context'), 3)
+        ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)
+        diff_context_size = h.get_diff_context_size(request.GET)
 
         c.a_rev = self._get_ref_rev(c.a_repo, org_ref_type, org_ref_name,
             returnempty=True)
@@ -225,9 +119,8 b' class CompareController(BaseRepoControll'
         c.cs_ref_name = other_ref_name
         c.cs_ref_type = other_ref_type
 
-        c.cs_ranges, c.cs_ranges_org, c.ancestors = self._get_changesets(
-            c.a_repo.scm_instance.alias, c.a_repo.scm_instance, c.a_rev,
-            c.cs_repo.scm_instance, c.cs_rev)
+        c.cs_ranges, c.cs_ranges_org, c.ancestors = c.a_repo.scm_instance.get_diff_changesets(
+            c.a_rev, c.cs_repo.scm_instance, c.cs_rev)
         raw_ids = [x.raw_id for x in c.cs_ranges]
         c.cs_comments = c.cs_repo.get_comments(raw_ids)
         c.cs_statuses = c.cs_repo.statuses(raw_ids)
@@ -236,7 +129,7 b' class CompareController(BaseRepoControll'
         c.jsdata = graph_data(c.cs_repo.scm_instance, revs)
 
         if partial:
-            return render('compare/compare_cs.html')
+            return base.render('compare/compare_cs.html')
 
         org_repo = c.a_repo
         other_repo = c.cs_repo
@@ -252,7 +145,7 b' class CompareController(BaseRepoControll'
             else:
                 msg = _('Multiple merge ancestors found for merge compare')
             if rev1 is None:
-                h.flash(msg, category='error')
+                webutils.flash(msg, category='error')
                 log.error(msg)
                 raise HTTPNotFound
 
@@ -266,7 +159,7 b' class CompareController(BaseRepoControll'
             if org_repo != other_repo:
                 # TODO: we could do this by using hg unionrepo
                 log.error('cannot compare across repos %s and %s', org_repo, other_repo)
-                h.flash(_('Cannot compare repositories without using common ancestor'), category='error')
+                webutils.flash(_('Cannot compare repositories without using common ancestor'), category='error')
                 raise HTTPBadRequest
             rev1 = c.a_rev
 
@@ -275,8 +168,8 b' class CompareController(BaseRepoControll'
         log.debug('running diff between %s and %s in %s',
                   rev1, c.cs_rev, org_repo.scm_instance.path)
         raw_diff = diffs.get_diff(org_repo.scm_instance, rev1=rev1, rev2=c.cs_rev,
-                                      ignore_whitespace=ignore_whitespace,
-                                      context=line_context)
+                                      ignore_whitespace=ignore_whitespace_diff,
+                                      context=diff_context_size)
 
         diff_processor = diffs.DiffProcessor(raw_diff, diff_limit=diff_limit)
         c.limited_diff = diff_processor.limited_diff
@@ -289,7 +182,7 b' class CompareController(BaseRepoControll'
             c.lines_deleted += st['deleted']
             filename = f['filename']
             fid = h.FID('', filename)
-            html_diff = diffs.as_html(enable_comments=False, parsed_lines=[f])
+            html_diff = diffs.as_html(parsed_lines=[f])
             c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))
 
-        return render('compare/compare_diff.html')
+        return base.render('compare/compare_diff.html')

kallithea/controllers/error.py

@@ -32,13 +32,13 b' from tg import config, expose, request'
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
 
-from kallithea.lib.base import BaseController
+from kallithea.controllers import base
 
 
 log = logging.getLogger(__name__)
 
 
-class ErrorController(BaseController):
+class ErrorController(base.BaseController):
     """Generates error documents as and when they are required.
 
     The errorpage middleware renders /error/document when error

kallithea/controllers/feed.py

@@ -33,19 +33,19 b' from tg import response'
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
 
-from kallithea import CONFIG
-from kallithea.lib import feeds
-from kallithea.lib import helpers as h
+import kallithea
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.lib import feeds, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController
 from kallithea.lib.diffs import DiffProcessor
-from kallithea.lib.utils2 import safe_int, safe_str, str2bool
+from kallithea.lib.utils2 import asbool, safe_int, safe_str
 
 
 log = logging.getLogger(__name__)
 
 
-class FeedController(BaseRepoController):
+class FeedController(base.BaseRepoController):
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -53,11 +53,11 b' class FeedController(BaseRepoController)'
         super(FeedController, self)._before(*args, **kwargs)
 
     def _get_title(self, cs):
-        return h.shorter(cs.message, 160)
+        return webutils.shorter(cs.message, 160)
 
     def __get_desc(self, cs):
         desc_msg = [(_('%s committed on %s')
-                     % (h.person(cs.author), h.fmt_date(cs.date))) + '<br/>']
+                     % (h.person(cs.author), webutils.fmt_date(cs.date))) + '<br/>']
         # branches, tags, bookmarks
         for branch in cs.branches:
             desc_msg.append('branch: %s<br/>' % branch)
@@ -67,11 +67,11 b' class FeedController(BaseRepoController)'
             desc_msg.append('tag: %s<br/>' % tag)
 
         changes = []
-        diff_limit = safe_int(CONFIG.get('rss_cut_off_limit', 32 * 1024))
+        diff_limit = safe_int(kallithea.CONFIG.get('rss_cut_off_limit', 32 * 1024))
         raw_diff = cs.diff()
         diff_processor = DiffProcessor(raw_diff,
                                        diff_limit=diff_limit,
-                                       inline_diff=False)
+                                       html=False)
 
         for st in diff_processor.parsed:
             st.update({'added': st['stats']['added'],
@@ -84,15 +84,15 b' class FeedController(BaseRepoController)'
                                  _('Changeset was too big and was cut off...')]
 
         # rev link
-        _url = h.canonical_url('changeset_home', repo_name=c.db_repo.repo_name,
+        _url = webutils.canonical_url('changeset_home', repo_name=c.db_repo.repo_name,
                    revision=cs.raw_id)
         desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))
 
         desc_msg.append('<pre>')
-        desc_msg.append(h.urlify_text(cs.message))
+        desc_msg.append(webutils.urlify_text(cs.message))
         desc_msg.append('\n')
         desc_msg.extend(changes)
-        if str2bool(CONFIG.get('rss_include_diff', False)):
+        if asbool(kallithea.CONFIG.get('rss_include_diff', False)):
             desc_msg.append('\n\n')
             desc_msg.append(safe_str(raw_diff))
         desc_msg.append('</pre>')
@@ -105,16 +105,16 b' class FeedController(BaseRepoController)'
         def _get_feed_from_cache(*_cache_keys):  # parameters are not really used - only as caching key
             header = dict(
                 title=_('%s %s feed') % (c.site_name, repo_name),
-                link=h.canonical_url('summary_home', repo_name=repo_name),
+                link=webutils.canonical_url('summary_home', repo_name=repo_name),
                 description=_('Changes on %s repository') % repo_name,
             )
 
-            rss_items_per_page = safe_int(CONFIG.get('rss_items_per_page', 20))
+            rss_items_per_page = safe_int(kallithea.CONFIG.get('rss_items_per_page', 20))
             entries=[]
             for cs in reversed(list(c.db_repo_scm_instance[-rss_items_per_page:])):
                 entries.append(dict(
                     title=self._get_title(cs),
-                    link=h.canonical_url('changeset_home', repo_name=repo_name, revision=cs.raw_id),
+                    link=webutils.canonical_url('changeset_home', repo_name=repo_name, revision=cs.raw_id),
                     author_email=cs.author_email,
                     author_name=cs.author_name,
                     description=''.join(self.__get_desc(cs)),

kallithea/controllers/files.py

@@ -38,21 +38,21 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound, HTTPNotFound
 
-from kallithea.config.routing import url
-from kallithea.controllers.changeset import _context_url, _ignorews_url, anchor_url, get_ignore_ws, get_line_ctx
-from kallithea.lib import diffs
-from kallithea.lib import helpers as h
+import kallithea
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.lib import diffs, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, jsonify, render
 from kallithea.lib.exceptions import NonRelativePathError
-from kallithea.lib.utils import action_logger
-from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_int, safe_str, str2bool
+from kallithea.lib.utils2 import asbool, convert_line_endings, detect_mode, safe_str
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.lib.vcs.conf import settings
 from kallithea.lib.vcs.exceptions import (ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError,
                                           NodeDoesNotExistError, NodeError, RepositoryError, VCSError)
 from kallithea.lib.vcs.nodes import FileNode
-from kallithea.model import db
+from kallithea.lib.vcs.utils import author_email
+from kallithea.lib.webutils import url
+from kallithea.model import userlog
 from kallithea.model.repo import RepoModel
 from kallithea.model.scm import ScmModel
 
@@ -60,7 +60,7 b' from kallithea.model.scm import ScmModel'
 log = logging.getLogger(__name__)
 
 
-class FilesController(BaseRepoController):
+class FilesController(base.BaseRepoController):
 
     def _before(self, *args, **kwargs):
         super(FilesController, self)._before(*args, **kwargs)
@@ -82,15 +82,15 b' class FilesController(BaseRepoController'
             url_ = url('files_add_home',
                        repo_name=c.repo_name,
                        revision=0, f_path='', anchor='edit')
-            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")
-            h.flash(_('There are no files yet.') + ' ' + add_new, category='warning')
+            add_new = webutils.link_to(_('Click here to add new file'), url_, class_="alert-link")
+            webutils.flash(_('There are no files yet.') + ' ' + add_new, category='warning')
             raise HTTPNotFound()
         except (ChangesetDoesNotExistError, LookupError):
             msg = _('Such revision does not exist for this repository')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
             raise HTTPNotFound()
 
     def __get_filenode(self, cs, path):
@@ -107,10 +107,10 b' class FilesController(BaseRepoController'
                 raise RepositoryError('given path is a directory')
         except ChangesetDoesNotExistError:
             msg = _('Such revision does not exist for this repository')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
             raise HTTPNotFound()
 
         return file_node
@@ -171,30 +171,30 b' class FilesController(BaseRepoController'
 
                 c.authors = []
                 for a in set([x.author for x in _hist]):
-                    c.authors.append((h.email(a), h.person(a)))
+                    c.authors.append((author_email(a), h.person(a)))
             else:
                 c.authors = c.file_history = []
         except RepositoryError as e:
-            h.flash(e, category='error')
+            webutils.flash(e, category='error')
             raise HTTPNotFound()
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('files/files_ypjax.html')
+            return base.render('files/files_ypjax.html')
 
         # TODO: tags and bookmarks?
         c.revision_options = [(c.changeset.raw_id,
-                              _('%s at %s') % (b, h.short_id(c.changeset.raw_id))) for b in c.changeset.branches] + \
+                              _('%s at %s') % (b, c.changeset.short_id)) for b in c.changeset.branches] + \
             [(n, b) for b, n in c.db_repo_scm_instance.branches.items()]
         if c.db_repo_scm_instance.closed_branches:
             prefix = _('(closed)') + ' '
             c.revision_options += [('-', '-')] + \
                 [(n, prefix + b) for b, n in c.db_repo_scm_instance.closed_branches.items()]
 
-        return render('files/files.html')
+        return base.render('files/files.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def history(self, repo_name, revision, f_path):
         changeset = self.__get_cs(revision)
         _file = changeset.get_node(f_path)
@@ -223,8 +223,8 b' class FilesController(BaseRepoController'
             file_history, _hist = self._get_node_history(changeset, f_path)
             c.authors = []
             for a in set([x.author for x in _hist]):
-                c.authors.append((h.email(a), h.person(a)))
-            return render('files/files_history_box.html')
+                c.authors.append((author_email(a), h.person(a)))
+            return base.render('files/files_history_box.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -233,7 +233,7 b' class FilesController(BaseRepoController'
         file_node = self.__get_filenode(cs, f_path)
 
         response.content_disposition = \
-            'attachment; filename=%s' % f_path.split(db.URL_SEP)[-1]
+            'attachment; filename=%s' % f_path.split(kallithea.URL_SEP)[-1]
 
         response.content_type = file_node.mimetype
         return file_node.content
@@ -292,9 +292,9 b' class FilesController(BaseRepoController'
         _branches = repo.scm_instance.branches
         # check if revision is a branch name or branch hash
         if revision not in _branches and revision not in _branches.values():
-            h.flash(_('You can only delete files with revision '
+            webutils.flash(_('You can only delete files with revision '
                       'being a valid branch'), category='warning')
-            raise HTTPFound(location=h.url('files_home',
+            raise HTTPFound(location=webutils.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
@@ -327,15 +327,15 b' class FilesController(BaseRepoController'
                     author=author,
                 )
 
-                h.flash(_('Successfully deleted file %s') % f_path,
+                webutils.flash(_('Successfully deleted file %s') % f_path,
                         category='success')
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during commit'), category='error')
+                webutils.flash(_('Error occurred during commit'), category='error')
             raise HTTPFound(location=url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
 
-        return render('files/files_delete.html')
+        return base.render('files/files_delete.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('write')
@@ -346,9 +346,9 b' class FilesController(BaseRepoController'
         _branches = repo.scm_instance.branches
         # check if revision is a branch name or branch hash
         if revision not in _branches and revision not in _branches.values():
-            h.flash(_('You can only edit files with revision '
+            webutils.flash(_('You can only edit files with revision '
                       'being a valid branch'), category='warning')
-            raise HTTPFound(location=h.url('files_home',
+            raise HTTPFound(location=webutils.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
@@ -375,7 +375,7 b' class FilesController(BaseRepoController'
             author = request.authuser.full_contact
 
             if content == old_content:
-                h.flash(_('No changes'), category='warning')
+                webutils.flash(_('No changes'), category='warning')
                 raise HTTPFound(location=url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
             try:
@@ -385,15 +385,15 b' class FilesController(BaseRepoController'
                                              ip_addr=request.ip_addr,
                                              author=author, message=message,
                                              content=content, f_path=f_path)
-                h.flash(_('Successfully committed to %s') % f_path,
+                webutils.flash(_('Successfully committed to %s') % f_path,
                         category='success')
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during commit'), category='error')
+                webutils.flash(_('Error occurred during commit'), category='error')
             raise HTTPFound(location=url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
 
-        return render('files/files_edit.html')
+        return base.render('files/files_edit.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('write')
@@ -425,11 +425,11 b' class FilesController(BaseRepoController'
                     content = content.file
 
             if not content:
-                h.flash(_('No content'), category='warning')
+                webutils.flash(_('No content'), category='warning')
                 raise HTTPFound(location=url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
             if not filename:
-                h.flash(_('No filename'), category='warning')
+                webutils.flash(_('No filename'), category='warning')
                 raise HTTPFound(location=url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
             # strip all crap out of file, just leave the basename
@@ -453,22 +453,22 b' class FilesController(BaseRepoController'
                     author=author,
                 )
 
-                h.flash(_('Successfully committed to %s') % node_path,
+                webutils.flash(_('Successfully committed to %s') % node_path,
                         category='success')
             except NonRelativePathError as e:
-                h.flash(_('Location must be relative path and must not '
+                webutils.flash(_('Location must be relative path and must not '
                           'contain .. in path'), category='warning')
                 raise HTTPFound(location=url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
             except (NodeError, NodeAlreadyExistsError) as e:
-                h.flash(_(e), category='error')
+                webutils.flash(_(e), category='error')
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during commit'), category='error')
+                webutils.flash(_('Error occurred during commit'), category='error')
             raise HTTPFound(location=url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
 
-        return render('files/files_add.html')
+        return base.render('files/files_add.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -505,13 +505,12 b' class FilesController(BaseRepoController'
         except (ImproperArchiveTypeError, KeyError):
             return _('Unknown archive type')
 
-        from kallithea import CONFIG
         rev_name = cs.raw_id[:12]
         archive_name = '%s-%s%s' % (repo_name.replace('/', '_'), rev_name, ext)
 
         archive_path = None
         cached_archive_path = None
-        archive_cache_dir = CONFIG.get('archive_cache_dir')
+        archive_cache_dir = kallithea.CONFIG.get('archive_cache_dir')
         if archive_cache_dir and not subrepos: # TODO: subrepo caching?
             if not os.path.isdir(archive_cache_dir):
                 os.makedirs(archive_cache_dir)
@@ -547,7 +546,7 b' class FilesController(BaseRepoController'
                 log.debug('Destroying temp archive %s', archive_path)
                 os.remove(archive_path)
 
-        action_logger(user=request.authuser,
+        userlog.action_logger(user=request.authuser,
                       action='user_downloaded_archive:%s' % (archive_name),
                       repo=repo_name, ipaddr=request.ip_addr, commit=True)
 
@@ -558,8 +557,8 b' class FilesController(BaseRepoController'
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
     def diff(self, repo_name, f_path):
-        ignore_whitespace = request.GET.get('ignorews') == '1'
-        line_context = safe_int(request.GET.get('context'), 3)
+        ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)
+        diff_context_size = h.get_diff_context_size(request.GET)
         diff2 = request.GET.get('diff2', '')
         diff1 = request.GET.get('diff1', '') or diff2
         c.action = request.GET.get('diff')
@@ -567,9 +566,6 b' class FilesController(BaseRepoController'
         c.f_path = f_path
         c.big_diff = False
         fulldiff = request.GET.get('fulldiff')
-        c.anchor_url = anchor_url
-        c.ignorews_url = _ignorews_url
-        c.context_url = _context_url
         c.changes = OrderedDict()
         c.changes[diff2] = []
 
@@ -577,7 +573,7 b' class FilesController(BaseRepoController'
         # to reduce JS and callbacks
 
         if request.GET.get('show_rev'):
-            if str2bool(request.GET.get('annotate', 'False')):
+            if asbool(request.GET.get('annotate', 'False')):
                 _url = url('files_annotate_home', repo_name=c.repo_name,
                            revision=diff1, f_path=c.f_path)
             else:
@@ -624,8 +620,8 b' class FilesController(BaseRepoController'
 
         if c.action == 'download':
             raw_diff = diffs.get_gitdiff(node1, node2,
-                                      ignore_whitespace=ignore_whitespace,
-                                      context=line_context)
+                                      ignore_whitespace=ignore_whitespace_diff,
+                                      context=diff_context_size)
             diff_name = '%s_vs_%s.diff' % (diff1, diff2)
             response.content_type = 'text/plain'
             response.content_disposition = (
@@ -635,26 +631,21 b' class FilesController(BaseRepoController'
 
         elif c.action == 'raw':
             raw_diff = diffs.get_gitdiff(node1, node2,
-                                      ignore_whitespace=ignore_whitespace,
-                                      context=line_context)
+                                      ignore_whitespace=ignore_whitespace_diff,
+                                      context=diff_context_size)
             response.content_type = 'text/plain'
             return raw_diff
 
         else:
             fid = h.FID(diff2, node2.path)
-            line_context_lcl = get_line_ctx(fid, request.GET)
-            ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
-
             diff_limit = None if fulldiff else self.cut_off_limit
-            c.a_rev, c.cs_rev, a_path, diff, st, op = diffs.wrapped_diff(filenode_old=node1,
+            c.a_rev, c.cs_rev, a_path, diff, st, op = diffs.html_diff(filenode_old=node1,
                                          filenode_new=node2,
                                          diff_limit=diff_limit,
-                                         ignore_whitespace=ign_whitespace_lcl,
-                                         line_context=line_context_lcl,
-                                         enable_comments=False)
+                                         ignore_whitespace=ignore_whitespace_diff,
+                                         line_context=diff_context_size)
             c.file_diff_data = [(fid, fid, op, a_path, node2.path, diff, st)]
-
-            return render('files/file_diff.html')
+            return base.render('files/file_diff.html')
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
@@ -695,14 +686,14 b' class FilesController(BaseRepoController'
                 node2 = FileNode(f_path, '', changeset=c.changeset_2)
         except ChangesetDoesNotExistError as e:
             msg = _('Such revision does not exist for this repository')
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
             raise HTTPNotFound()
         c.node1 = node1
         c.node2 = node2
         c.cs1 = c.changeset_1
         c.cs2 = c.changeset_2
 
-        return render('files/diff_2way.html')
+        return base.render('files/diff_2way.html')
 
     def _get_node_history(self, cs, f_path, changesets=None):
         """
@@ -745,7 +736,7 b' class FilesController(BaseRepoController'
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def nodelist(self, repo_name, revision, f_path):
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             cs = self.__get_cs(revision)

kallithea/controllers/followers.py

@@ -30,28 +30,28 b' import logging'
 from tg import request
 from tg import tmpl_context as c
 
+from kallithea.controllers import base
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, render
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int
-from kallithea.model.db import UserFollowing
+from kallithea.model import db
 
 
 log = logging.getLogger(__name__)
 
 
-class FollowersController(BaseRepoController):
+class FollowersController(base.BaseRepoController):
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
     def followers(self, repo_name):
         p = safe_int(request.GET.get('page'), 1)
         repo_id = c.db_repo.repo_id
-        d = UserFollowing.get_repo_followers(repo_id) \
-            .order_by(UserFollowing.follows_from)
+        d = db.UserFollowing.get_repo_followers(repo_id) \
+            .order_by(db.UserFollowing.follows_from)
         c.followers_pager = Page(d, page=p, items_per_page=20)
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('/followers/followers_data.html')
+            return base.render('/followers/followers_data.html')
 
-        return render('/followers/followers.html')
+        return base.render('/followers/followers.html')

kallithea/controllers/forks.py

@@ -33,16 +33,15 b' from formencode import htmlfill'
 from tg import request
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
-from webob.exc import HTTPFound
+from webob.exc import HTTPFound, HTTPNotFound
 
 import kallithea
-import kallithea.lib.helpers as h
-from kallithea.config.routing import url
-from kallithea.lib.auth import HasPermissionAny, HasPermissionAnyDecorator, HasRepoPermissionLevel, HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, render
+from kallithea.controllers import base
+from kallithea.lib import webutils
+from kallithea.lib.auth import HasPermissionAnyDecorator, HasRepoPermissionLevel, HasRepoPermissionLevelDecorator, LoginRequired
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int
-from kallithea.model.db import Repository, Ui, UserFollowing
+from kallithea.model import db
 from kallithea.model.forms import RepoForkForm
 from kallithea.model.repo import RepoModel
 from kallithea.model.scm import AvailableRepoGroupChoices, ScmModel
@@ -51,18 +50,14 b' from kallithea.model.scm import Availabl'
 log = logging.getLogger(__name__)
 
 
-class ForksController(BaseRepoController):
+class ForksController(base.BaseRepoController):
 
     def __load_defaults(self):
-        if HasPermissionAny('hg.create.write_on_repogroup.true')():
-            repo_group_perm_level = 'write'
-        else:
-            repo_group_perm_level = 'admin'
-        c.repo_groups = AvailableRepoGroupChoices(['hg.create.repository'], repo_group_perm_level)
+        c.repo_groups = AvailableRepoGroupChoices('write')
 
         c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs()
 
-        c.can_update = Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active
+        c.can_update = db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE).ui_active
 
     def __load_data(self):
         """
@@ -74,13 +69,12 b' class ForksController(BaseRepoController'
         repo = c.db_repo.scm_instance
 
         if c.repo_info is None:
-            h.not_mapped_error(c.repo_name)
-            raise HTTPFound(location=url('repos'))
+            raise HTTPNotFound()
 
         c.default_user_id = kallithea.DEFAULT_USER_ID
-        c.in_public_journal = UserFollowing.query() \
-            .filter(UserFollowing.user_id == c.default_user_id) \
-            .filter(UserFollowing.follows_repository == c.repo_info).scalar()
+        c.in_public_journal = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == c.default_user_id) \
+            .filter(db.UserFollowing.follows_repository == c.repo_info).scalar()
 
         if c.repo_info.stats:
             last_rev = c.repo_info.stats.stat_on_revision + 1
@@ -112,30 +106,29 b' class ForksController(BaseRepoController'
         p = safe_int(request.GET.get('page'), 1)
         repo_id = c.db_repo.repo_id
         d = []
-        for r in Repository.get_repo_forks(repo_id):
+        for r in db.Repository.get_repo_forks(repo_id):
             if not HasRepoPermissionLevel('read')(r.repo_name, 'get forks check'):
                 continue
             d.append(r)
         c.forks_pager = Page(d, page=p, items_per_page=20)
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('/forks/forks_data.html')
+            return base.render('/forks/forks_data.html')
 
-        return render('/forks/forks.html')
+        return base.render('/forks/forks.html')
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionLevelDecorator('read')
     def fork(self, repo_name):
-        c.repo_info = Repository.get_by_repo_name(repo_name)
+        c.repo_info = db.Repository.get_by_repo_name(repo_name)
         if not c.repo_info:
-            h.not_mapped_error(repo_name)
-            raise HTTPFound(location=url('home'))
+            raise HTTPNotFound()
 
         defaults = self.__load_data()
 
         return htmlfill.render(
-            render('forks/fork.html'),
+            base.render('forks/fork.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
@@ -145,26 +138,24 b' class ForksController(BaseRepoController'
     @HasRepoPermissionLevelDecorator('read')
     def fork_create(self, repo_name):
         self.__load_defaults()
-        c.repo_info = Repository.get_by_repo_name(repo_name)
+        c.repo_info = db.Repository.get_by_repo_name(repo_name)
         _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},
                              repo_groups=c.repo_groups,
                              landing_revs=c.landing_revs_choices)()
         form_result = {}
-        task_id = None
         try:
             form_result = _form.to_python(dict(request.POST))
 
             # an approximation that is better than nothing
-            if not Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active:
+            if not db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE).ui_active:
                 form_result['update_after_clone'] = False
 
             # create fork is done sometimes async on celery, db transaction
             # management is handled there.
-            task = RepoModel().create_fork(form_result, request.authuser.user_id)
-            task_id = task.task_id
+            RepoModel().create_fork(form_result, request.authuser.user_id)
         except formencode.Invalid as errors:
             return htmlfill.render(
-                render('forks/fork.html'),
+                base.render('forks/fork.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -172,9 +163,9 b' class ForksController(BaseRepoController'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during repository forking %s') %
+            webutils.flash(_('An error occurred during repository forking %s') %
                     repo_name, category='error')
 
-        raise HTTPFound(location=h.url('repo_creating_home',
+        raise HTTPFound(location=webutils.url('repo_creating_home',
                               repo_name=form_result['repo_name_full'],
-                              task_id=task_id))
+                              ))

kallithea/controllers/home.py

@@ -34,11 +34,11 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest
 
-from kallithea.lib import helpers as h
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseController, jsonify, render
 from kallithea.lib.utils2 import safe_str
-from kallithea.model.db import RepoGroup, Repository, User, UserGroup
+from kallithea.model import db
 from kallithea.model.repo import RepoModel
 from kallithea.model.scm import UserGroupList
 
@@ -46,31 +46,31 b' from kallithea.model.scm import UserGrou'
 log = logging.getLogger(__name__)
 
 
-class HomeController(BaseController):
+class HomeController(base.BaseController):
 
     def about(self):
-        return render('/about.html')
+        return base.render('/about.html')
 
     @LoginRequired(allow_default_user=True)
     def index(self):
         c.group = None
 
         repo_groups_list = self.scm_model.get_repo_groups()
-        repos_list = Repository.query(sorted=True).filter_by(group=None).all()
+        repos_list = db.Repository.query(sorted=True).filter_by(group=None).all()
 
         c.data = RepoModel().get_repos_as_dict(repos_list,
                                                repo_groups_list=repo_groups_list,
                                                short_name=True)
 
-        return render('/index.html')
+        return base.render('/index.html')
 
     @LoginRequired(allow_default_user=True)
-    @jsonify
+    @base.jsonify
     def repo_switcher_data(self):
         if request.is_xhr:
-            all_repos = Repository.query(sorted=True).all()
+            all_repos = db.Repository.query(sorted=True).all()
             repo_iter = self.scm_model.get_repos(all_repos)
-            all_groups = RepoGroup.query(sorted=True).all()
+            all_groups = db.RepoGroup.query(sorted=True).all()
             repo_groups_iter = self.scm_model.get_repo_groups(all_groups)
 
             res = [{
@@ -109,9 +109,9 b' class HomeController(BaseController):'
 
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def repo_refs_data(self, repo_name):
-        repo = Repository.get_by_repo_name(repo_name).scm_instance
+        repo = db.Repository.get_by_repo_name(repo_name).scm_instance
         res = []
         _branches = repo.branches.items()
         if _branches:
@@ -144,7 +144,7 b' class HomeController(BaseController):'
         return data
 
     @LoginRequired()
-    @jsonify
+    @base.jsonify
     def users_and_groups_data(self):
         """
         Returns 'results' with a list of users and user groups.
@@ -163,19 +163,20 b' class HomeController(BaseController):'
         if 'users' in types:
             user_list = []
             if key:
-                u = User.get_by_username(key)
+                u = db.User.get_by_username(key)
                 if u:
                     user_list = [u]
             elif query:
-                user_list = User.query() \
-                    .filter(User.is_default_user == False) \
-                    .filter(User.active == True) \
+                user_list = db.User.query() \
+                    .filter(db.User.is_default_user == False) \
+                    .filter(db.User.active == True) \
                     .filter(or_(
-                        User.username.ilike("%%" + query + "%%"),
-                        User.name.ilike("%%" + query + "%%"),
-                        User.lastname.ilike("%%" + query + "%%"),
+                        db.User.username.ilike("%%" + query + "%%"),
+                        db.User.name.concat(' ').concat(db.User.lastname).ilike("%%" + query + "%%"),
+                        db.User.lastname.concat(' ').concat(db.User.name).ilike("%%" + query + "%%"),
+                        db.User.email.ilike("%%" + query + "%%"),
                     )) \
-                    .order_by(User.username) \
+                    .order_by(db.User.username) \
                     .limit(500) \
                     .all()
             for u in user_list:
@@ -191,14 +192,14 b' class HomeController(BaseController):'
         if 'groups' in types:
             grp_list = []
             if key:
-                grp = UserGroup.get_by_group_name(key)
+                grp = db.UserGroup.get_by_group_name(key)
                 if grp:
                     grp_list = [grp]
             elif query:
-                grp_list = UserGroup.query() \
-                    .filter(UserGroup.users_group_name.ilike("%%" + query + "%%")) \
-                    .filter(UserGroup.users_group_active == True) \
-                    .order_by(UserGroup.users_group_name) \
+                grp_list = db.UserGroup.query() \
+                    .filter(db.UserGroup.users_group_name.ilike("%%" + query + "%%")) \
+                    .filter(db.UserGroup.users_group_active == True) \
+                    .order_by(db.UserGroup.users_group_name) \
                     .limit(500) \
                     .all()
             for g in UserGroupList(grp_list, perm_level='read'):

kallithea/controllers/journal.py

@@ -37,14 +37,13 b' from tg.i18n import ugettext as _'
 from webob.exc import HTTPBadRequest
 
 import kallithea.lib.helpers as h
+from kallithea.controllers import base
 from kallithea.controllers.admin.admin import _journal_filter
-from kallithea.lib import feeds
+from kallithea.lib import feeds, webutils
 from kallithea.lib.auth import LoginRequired
-from kallithea.lib.base import BaseController, render
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import AttributeDict, safe_int
-from kallithea.model.db import Repository, User, UserFollowing, UserLog
-from kallithea.model.meta import Session
+from kallithea.model import db, meta
 from kallithea.model.repo import RepoModel
 
 
@@ -56,7 +55,7 b' ttl = "5"'
 feed_nr = 20
 
 
-class JournalController(BaseController):
+class JournalController(base.BaseController):
 
     def _before(self, *args, **kwargs):
         super(JournalController, self)._before(*args, **kwargs)
@@ -84,20 +83,20 b' class JournalController(BaseController):'
         filtering_criterion = None
 
         if repo_ids and user_ids:
-            filtering_criterion = or_(UserLog.repository_id.in_(repo_ids),
-                        UserLog.user_id.in_(user_ids))
+            filtering_criterion = or_(db.UserLog.repository_id.in_(repo_ids),
+                        db.UserLog.user_id.in_(user_ids))
         if repo_ids and not user_ids:
-            filtering_criterion = UserLog.repository_id.in_(repo_ids)
+            filtering_criterion = db.UserLog.repository_id.in_(repo_ids)
         if not repo_ids and user_ids:
-            filtering_criterion = UserLog.user_id.in_(user_ids)
+            filtering_criterion = db.UserLog.user_id.in_(user_ids)
         if filtering_criterion is not None:
-            journal = UserLog.query() \
-                .options(joinedload(UserLog.user)) \
-                .options(joinedload(UserLog.repository))
+            journal = db.UserLog.query() \
+                .options(joinedload(db.UserLog.user)) \
+                .options(joinedload(db.UserLog.repository))
             # filter
             journal = _journal_filter(journal, c.search_term)
             journal = journal.filter(filtering_criterion) \
-                        .order_by(UserLog.action_date.desc())
+                        .order_by(db.UserLog.action_date.desc())
         else:
             journal = []
 
@@ -126,13 +125,13 b' class JournalController(BaseController):'
                                     entry.repository.repo_name)
             _url = None
             if entry.repository is not None:
-                _url = h.canonical_url('changelog_home',
+                _url = webutils.canonical_url('changelog_home',
                            repo_name=entry.repository.repo_name)
 
             entries.append(dict(
                 title=title,
                 pubdate=entry.action_date,
-                link=_url or h.canonical_url(''),
+                link=_url or webutils.canonical_url(''),
                 author_email=user.email,
                 author_name=user.full_name_or_username,
                 description=action_extra(),
@@ -142,22 +141,22 b' class JournalController(BaseController):'
 
     def _atom_feed(self, repos, public=True):
         if public:
-            link = h.canonical_url('public_journal_atom')
+            link = webutils.canonical_url('public_journal_atom')
             desc = '%s %s %s' % (c.site_name, _('Public Journal'),
                                   'atom feed')
         else:
-            link = h.canonical_url('journal_atom')
+            link = webutils.canonical_url('journal_atom')
             desc = '%s %s %s' % (c.site_name, _('Journal'), 'atom feed')
 
         return self._feed(repos, feeds.AtomFeed, link, desc)
 
     def _rss_feed(self, repos, public=True):
         if public:
-            link = h.canonical_url('public_journal_atom')
+            link = webutils.canonical_url('public_journal_atom')
             desc = '%s %s %s' % (c.site_name, _('Public Journal'),
                                   'rss feed')
         else:
-            link = h.canonical_url('journal_atom')
+            link = webutils.canonical_url('journal_atom')
             desc = '%s %s %s' % (c.site_name, _('Journal'), 'rss feed')
 
         return self._feed(repos, feeds.RssFeed, link, desc)
@@ -166,10 +165,10 b' class JournalController(BaseController):'
     def index(self):
         # Return a rendered template
         p = safe_int(request.GET.get('page'), 1)
-        c.user = User.get(request.authuser.user_id)
-        c.following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        c.user = db.User.get(request.authuser.user_id)
+        c.following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
 
         journal = self._get_journal_data(c.following)
@@ -179,32 +178,32 b' class JournalController(BaseController):'
         c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('journal/journal_data.html')
+            return base.render('journal/journal_data.html')
 
-        repos_list = Repository.query(sorted=True) \
+        repos_list = db.Repository.query(sorted=True) \
             .filter_by(owner_id=request.authuser.user_id).all()
 
         repos_data = RepoModel().get_repos_as_dict(repos_list, admin=True)
         # data used to render the grid
         c.data = repos_data
 
-        return render('journal/journal.html')
+        return base.render('journal/journal.html')
 
     @LoginRequired()
     def journal_atom(self):
         """Produce a simple atom-1.0 feed"""
-        following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
         return self._atom_feed(following, public=False)
 
     @LoginRequired()
     def journal_rss(self):
         """Produce a simple rss2 feed"""
-        following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
         return self._rss_feed(following, public=False)
 
@@ -215,7 +214,7 b' class JournalController(BaseController):'
             try:
                 self.scm_model.toggle_following_user(user_id,
                                             request.authuser.user_id)
-                Session().commit()
+                meta.Session().commit()
                 return 'ok'
             except Exception:
                 log.error(traceback.format_exc())
@@ -226,7 +225,7 b' class JournalController(BaseController):'
             try:
                 self.scm_model.toggle_following_repo(repo_id,
                                             request.authuser.user_id)
-                Session().commit()
+                meta.Session().commit()
                 return 'ok'
             except Exception:
                 log.error(traceback.format_exc())
@@ -239,9 +238,9 b' class JournalController(BaseController):'
         # Return a rendered template
         p = safe_int(request.GET.get('page'), 1)
 
-        c.following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        c.following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
 
         journal = self._get_journal_data(c.following)
@@ -251,16 +250,16 b' class JournalController(BaseController):'
         c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
-            return render('journal/journal_data.html')
+            return base.render('journal/journal_data.html')
 
-        return render('journal/public_journal.html')
+        return base.render('journal/public_journal.html')
 
     @LoginRequired(allow_default_user=True)
     def public_journal_atom(self):
         """Produce a simple atom-1.0 feed"""
-        c.following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        c.following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
 
         return self._atom_feed(c.following)
@@ -268,9 +267,9 b' class JournalController(BaseController):'
     @LoginRequired(allow_default_user=True)
     def public_journal_rss(self):
         """Produce a simple rss2 feed"""
-        c.following = UserFollowing.query() \
-            .filter(UserFollowing.user_id == request.authuser.user_id) \
-            .options(joinedload(UserFollowing.follows_repository)) \
+        c.following = db.UserFollowing.query() \
+            .filter(db.UserFollowing.user_id == request.authuser.user_id) \
+            .options(joinedload(db.UserFollowing.follows_repository)) \
             .all()
 
         return self._rss_feed(c.following)

kallithea/controllers/login.py

@@ -36,21 +36,21 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest, HTTPFound
 
-import kallithea.lib.helpers as h
-from kallithea.config.routing import url
+from kallithea.controllers import base
+from kallithea.lib import webutils
 from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator
-from kallithea.lib.base import BaseController, log_in_user, render
 from kallithea.lib.exceptions import UserCreationError
-from kallithea.model.db import Setting, User
+from kallithea.lib.recaptcha import submit
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.forms import LoginForm, PasswordResetConfirmationForm, PasswordResetRequestForm, RegisterForm
-from kallithea.model.meta import Session
 from kallithea.model.user import UserModel
 
 
 log = logging.getLogger(__name__)
 
 
-class LoginController(BaseController):
+class LoginController(base.BaseController):
 
     def _validate_came_from(self, came_from,
             _re=re.compile(r"/(?!/)[-!#$%&'()*+,./:;=?@_~0-9A-Za-z]*$")):
@@ -82,14 +82,14 b' class LoginController(BaseController):'
                 # login_form will check username/password using ValidAuth and report failure to the user
                 c.form_result = login_form.to_python(dict(request.POST))
                 username = c.form_result['username']
-                user = User.get_by_username_or_email(username)
+                user = db.User.get_by_username_or_email(username)
                 assert user is not None  # the same user get just passed in the form validation
             except formencode.Invalid as errors:
                 defaults = errors.value
                 # remove password from filling in form again
                 defaults.pop('password', None)
                 return htmlfill.render(
-                    render('/login.html'),
+                    base.render('/login.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -100,28 +100,28 b' class LoginController(BaseController):'
                 # the fly can throw this exception signaling that there's issue
                 # with user creation, explanation should be provided in
                 # Exception itself
-                h.flash(e, 'error')
+                webutils.flash(e, 'error')
             else:
                 # login_form already validated the password - now set the session cookie accordingly
-                auth_user = log_in_user(user, c.form_result['remember'], is_external_auth=False, ip_addr=request.ip_addr)
+                auth_user = base.log_in_user(user, c.form_result['remember'], is_external_auth=False, ip_addr=request.ip_addr)
                 if auth_user:
                     raise HTTPFound(location=c.came_from)
-                h.flash(_('Authentication failed.'), 'error')
+                webutils.flash(_('Authentication failed.'), 'error')
         else:
             # redirect if already logged in
             if not request.authuser.is_anonymous:
                 raise HTTPFound(location=c.came_from)
             # continue to show login to default user
 
-        return render('/login.html')
+        return base.render('/login.html')
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',
                                'hg.register.manual_activate')
     def register(self):
-        def_user_perms = AuthUser(dbuser=User.get_default_user()).permissions['global']
+        def_user_perms = AuthUser(dbuser=db.User.get_default_user()).global_permissions
         c.auto_active = 'hg.register.auto_activate' in def_user_perms
 
-        settings = Setting.get_app_settings()
+        settings = db.Setting.get_app_settings()
         captcha_private_key = settings.get('captcha_private_key')
         c.captcha_active = bool(captcha_private_key)
         c.captcha_public_key = settings.get('captcha_public_key')
@@ -133,7 +133,6 b' class LoginController(BaseController):'
                 form_result['active'] = c.auto_active
 
                 if c.captcha_active:
-                    from kallithea.lib.recaptcha import submit
                     response = submit(request.POST.get('g-recaptcha-response'),
                                       private_key=captcha_private_key,
                                       remoteip=request.ip_addr)
@@ -145,14 +144,14 b' class LoginController(BaseController):'
                                                  error_dict=error_dict)
 
                 UserModel().create_registration(form_result)
-                h.flash(_('You have successfully registered with %s') % (c.site_name or 'Kallithea'),
+                webutils.flash(_('You have successfully registered with %s') % (c.site_name or 'Kallithea'),
                         category='success')
-                Session().commit()
+                meta.Session().commit()
                 raise HTTPFound(location=url('login_home'))
 
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('/register.html'),
+                    base.render('/register.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
@@ -163,12 +162,12 b' class LoginController(BaseController):'
                 # the fly can throw this exception signaling that there's issue
                 # with user creation, explanation should be provided in
                 # Exception itself
-                h.flash(e, 'error')
+                webutils.flash(e, 'error')
 
-        return render('/register.html')
+        return base.render('/register.html')
 
     def password_reset(self):
-        settings = Setting.get_app_settings()
+        settings = db.Setting.get_app_settings()
         captcha_private_key = settings.get('captcha_private_key')
         c.captcha_active = bool(captcha_private_key)
         c.captcha_public_key = settings.get('captcha_public_key')
@@ -178,7 +177,6 b' class LoginController(BaseController):'
             try:
                 form_result = password_reset_form.to_python(dict(request.POST))
                 if c.captcha_active:
-                    from kallithea.lib.recaptcha import submit
                     response = submit(request.POST.get('g-recaptcha-response'),
                                       private_key=captcha_private_key,
                                       remoteip=request.ip_addr)
@@ -189,20 +187,20 b' class LoginController(BaseController):'
                         raise formencode.Invalid(_msg, _value, None,
                                                  error_dict=error_dict)
                 redirect_link = UserModel().send_reset_password_email(form_result)
-                h.flash(_('A password reset confirmation code has been sent'),
+                webutils.flash(_('A password reset confirmation code has been sent'),
                             category='success')
                 raise HTTPFound(location=redirect_link)
 
             except formencode.Invalid as errors:
                 return htmlfill.render(
-                    render('/password_reset.html'),
+                    base.render('/password_reset.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8",
                     force_defaults=False)
 
-        return render('/password_reset.html')
+        return base.render('/password_reset.html')
 
     def password_reset_confirmation(self):
         # This controller handles both GET and POST requests, though we
@@ -215,14 +213,14 b' class LoginController(BaseController):'
         c.timestamp = request.params.get('timestamp') or ''
         c.token = request.params.get('token') or ''
         if not request.POST:
-            return render('/password_reset_confirmation.html')
+            return base.render('/password_reset_confirmation.html')
 
         form = PasswordResetConfirmationForm()()
         try:
             form_result = form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             return htmlfill.render(
-                render('/password_reset_confirmation.html'),
+                base.render('/password_reset_confirmation.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
@@ -234,14 +232,14 b' class LoginController(BaseController):'
             form_result['token'],
         ):
             return htmlfill.render(
-                render('/password_reset_confirmation.html'),
+                base.render('/password_reset_confirmation.html'),
                 defaults=form_result,
                 errors={'token': _('Invalid password reset token')},
                 prefix_error=False,
                 encoding='UTF-8')
 
         UserModel().reset_password(form_result['email'], form_result['password'])
-        h.flash(_('Successfully updated password'), category='success')
+        webutils.flash(_('Successfully updated password'), category='success')
         raise HTTPFound(location=url('login_home'))
 
     def logout(self):
@@ -255,4 +253,4 b' class LoginController(BaseController):'
         Only intended for testing but might also be useful for other kinds
         of automation.
         """
-        return h.session_csrf_secret_token()
+        return webutils.session_csrf_secret_token()

kallithea/controllers/pullrequests.py

@@ -35,21 +35,20 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound
 
-from kallithea.config.routing import url
-from kallithea.controllers.changeset import _context_url, _ignorews_url, create_cs_pr_comment, delete_cs_pr_comment
-from kallithea.lib import diffs
-from kallithea.lib import helpers as h
+import kallithea.lib.helpers as h
+from kallithea.controllers import base
+from kallithea.controllers.changeset import create_cs_pr_comment, delete_cs_pr_comment
+from kallithea.lib import auth, diffs, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, jsonify, render
 from kallithea.lib.graphmod import graph_data
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import ascii_bytes, safe_bytes, safe_int
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError
+from kallithea.lib.webutils import url
+from kallithea.model import db, meta
 from kallithea.model.changeset_status import ChangesetStatusModel
 from kallithea.model.comment import ChangesetCommentsModel
-from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, Repository, User
 from kallithea.model.forms import PullRequestForm, PullRequestPostForm
-from kallithea.model.meta import Session
 from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel
 
 
@@ -59,21 +58,21 b' log = logging.getLogger(__name__)'
 def _get_reviewer(user_id):
     """Look up user by ID and validate it as a potential reviewer."""
     try:
-        user = User.get(int(user_id))
+        user = db.User.get(int(user_id))
     except ValueError:
         user = None
 
     if user is None or user.is_default_user:
-        h.flash(_('Invalid reviewer "%s" specified') % user_id, category='error')
+        webutils.flash(_('Invalid reviewer "%s" specified') % user_id, category='error')
         raise HTTPBadRequest()
 
     return user
 
 
-class PullrequestsController(BaseRepoController):
+class PullrequestsController(base.BaseRepoController):
 
     def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):
-        """return a structure with repo's interesting changesets, suitable for
+        """return a structure with scm repo's interesting changesets, suitable for
         the selectors in pullrequest.html
 
         rev: a revision that must be in the list somehow and selected by default
@@ -155,13 +154,14 b' class PullrequestsController(BaseRepoCon'
 
         # prio 4: tip revision
         if not selected:
-            if h.is_hg(repo):
+            if repo.alias == 'hg':
                 if tipbranch:
                     selected = 'branch:%s:%s' % (tipbranch, tiprev)
                 else:
                     selected = 'tag:null:' + repo.EMPTY_CHANGESET
                     tags.append((selected, 'null'))
             else:  # Git
+                assert repo.alias == 'git'
                 if not repo.branches:
                     selected = ''  # doesn't make sense, but better than nothing
                 elif 'master' in repo.branches:
@@ -183,9 +183,9 b' class PullrequestsController(BaseRepoCon'
             return False
 
         owner = request.authuser.user_id == pull_request.owner_id
-        reviewer = PullRequestReviewer.query() \
-            .filter(PullRequestReviewer.pull_request == pull_request) \
-            .filter(PullRequestReviewer.user_id == request.authuser.user_id) \
+        reviewer = db.PullRequestReviewer.query() \
+            .filter(db.PullRequestReviewer.pull_request == pull_request) \
+            .filter(db.PullRequestReviewer.user_id == request.authuser.user_id) \
             .count() != 0
 
         return request.authuser.admin or owner or reviewer
@@ -202,7 +202,7 b' class PullrequestsController(BaseRepoCon'
             url_params['closed'] = 1
         p = safe_int(request.GET.get('page'), 1)
 
-        q = PullRequest.query(include_closed=c.closed, sorted=True)
+        q = db.PullRequest.query(include_closed=c.closed, sorted=True)
         if c.from_:
             q = q.filter_by(org_repo=c.db_repo)
         else:
@@ -211,21 +211,21 b' class PullrequestsController(BaseRepoCon'
 
         c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100, **url_params)
 
-        return render('/pullrequests/pullrequest_show_all.html')
+        return base.render('/pullrequests/pullrequest_show_all.html')
 
     @LoginRequired()
     def show_my(self):
         c.closed = request.GET.get('closed') or ''
 
-        c.my_pull_requests = PullRequest.query(
+        c.my_pull_requests = db.PullRequest.query(
             include_closed=c.closed,
             sorted=True,
         ).filter_by(owner_id=request.authuser.user_id).all()
 
         c.participate_in_pull_requests = []
         c.participate_in_pull_requests_todo = []
-        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])
-        for pr in PullRequest.query(
+        done_status = set([db.ChangesetStatus.STATUS_APPROVED, db.ChangesetStatus.STATUS_REJECTED])
+        for pr in db.PullRequest.query(
             include_closed=c.closed,
             reviewer_id=request.authuser.user_id,
             sorted=True,
@@ -236,7 +236,7 b' class PullrequestsController(BaseRepoCon'
             else:
                 c.participate_in_pull_requests_todo.append(pr)
 
-        return render('/pullrequests/pullrequest_show_my.html')
+        return base.render('/pullrequests/pullrequest_show_my.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
@@ -246,7 +246,7 b' class PullrequestsController(BaseRepoCon'
         try:
             org_scm_instance.get_changeset()
         except EmptyRepositoryError as e:
-            h.flash(_('There are no changesets yet'),
+            webutils.flash(_('There are no changesets yet'),
                     category='warning')
             raise HTTPFound(location=url('summary_home', repo_name=org_repo.repo_name))
 
@@ -291,11 +291,11 b' class PullrequestsController(BaseRepoCon'
         for fork in org_repo.forks:
             c.a_repos.append((fork.repo_name, fork.repo_name))
 
-        return render('/pullrequests/pullrequest.html')
+        return base.render('/pullrequests/pullrequest.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def repo_info(self, repo_name):
         repo = c.db_repo
         refs, selected_ref = self._get_repo_refs(repo.scm_instance)
@@ -315,61 +315,61 b' class PullrequestsController(BaseRepoCon'
             log.error(traceback.format_exc())
             log.error(str(errors))
             msg = _('Error creating pull request: %s') % errors.msg
-            h.flash(msg, 'error')
+            webutils.flash(msg, 'error')
             raise HTTPBadRequest
 
         # heads up: org and other might seem backward here ...
         org_ref = _form['org_ref'] # will have merge_rev as rev but symbolic name
-        org_repo = Repository.guess_instance(_form['org_repo'])
+        org_repo = db.Repository.guess_instance(_form['org_repo'])
 
         other_ref = _form['other_ref'] # will have symbolic name and head revision
-        other_repo = Repository.guess_instance(_form['other_repo'])
+        other_repo = db.Repository.guess_instance(_form['other_repo'])
 
         reviewers = []
 
         title = _form['pullrequest_title']
         description = _form['pullrequest_desc'].strip()
-        owner = User.get(request.authuser.user_id)
+        owner = db.User.get(request.authuser.user_id)
 
         try:
             cmd = CreatePullRequestAction(org_repo, other_repo, org_ref, other_ref, title, description, owner, reviewers)
         except CreatePullRequestAction.ValidationError as e:
-            h.flash(e, category='error', logf=log.error)
+            webutils.flash(e, category='error', logf=log.error)
             raise HTTPNotFound
 
         try:
             pull_request = cmd.execute()
-            Session().commit()
+            meta.Session().commit()
         except Exception:
-            h.flash(_('Error occurred while creating pull request'),
+            webutils.flash(_('Error occurred while creating pull request'),
                     category='error')
             log.error(traceback.format_exc())
             raise HTTPFound(location=url('pullrequest_home', repo_name=repo_name))
 
-        h.flash(_('Successfully opened new pull request'),
+        webutils.flash(_('Successfully opened new pull request'),
                 category='success')
         raise HTTPFound(location=pull_request.url())
 
     def create_new_iteration(self, old_pull_request, new_rev, title, description, reviewers):
-        owner = User.get(request.authuser.user_id)
+        owner = db.User.get(request.authuser.user_id)
         new_org_rev = self._get_ref_rev(old_pull_request.org_repo, 'rev', new_rev)
         new_other_rev = self._get_ref_rev(old_pull_request.other_repo, old_pull_request.other_ref_parts[0], old_pull_request.other_ref_parts[1])
         try:
             cmd = CreatePullRequestIterationAction(old_pull_request, new_org_rev, new_other_rev, title, description, owner, reviewers)
         except CreatePullRequestAction.ValidationError as e:
-            h.flash(e, category='error', logf=log.error)
+            webutils.flash(e, category='error', logf=log.error)
             raise HTTPNotFound
 
         try:
             pull_request = cmd.execute()
-            Session().commit()
+            meta.Session().commit()
         except Exception:
-            h.flash(_('Error occurred while creating pull request'),
+            webutils.flash(_('Error occurred while creating pull request'),
                     category='error')
             log.error(traceback.format_exc())
             raise HTTPFound(location=old_pull_request.url())
 
-        h.flash(_('New pull request iteration created'),
+        webutils.flash(_('New pull request iteration created'),
                 category='success')
         raise HTTPFound(location=pull_request.url())
 
@@ -377,14 +377,14 b' class PullrequestsController(BaseRepoCon'
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
     def post(self, repo_name, pull_request_id):
-        pull_request = PullRequest.get_or_404(pull_request_id)
+        pull_request = db.PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
         assert pull_request.other_repo.repo_name == repo_name
         # only owner or admin can update it
         owner = pull_request.owner_id == request.authuser.user_id
-        repo_admin = h.HasRepoPermissionLevel('admin')(c.repo_name)
-        if not (h.HasPermissionAny('hg.admin')() or repo_admin or owner):
+        repo_admin = auth.HasRepoPermissionLevel('admin')(c.repo_name)
+        if not (auth.HasPermissionAny('hg.admin')() or repo_admin or owner):
             raise HTTPForbidden()
 
         _form = PullRequestPostForm()().to_python(request.POST)
@@ -397,11 +397,11 b' class PullrequestsController(BaseRepoCon'
         other_removed = old_reviewers - cur_reviewers
 
         if other_added:
-            h.flash(_('Meanwhile, the following reviewers have been added: %s') %
+            webutils.flash(_('Meanwhile, the following reviewers have been added: %s') %
                     (', '.join(u.username for u in other_added)),
                     category='warning')
         if other_removed:
-            h.flash(_('Meanwhile, the following reviewers have been removed: %s') %
+            webutils.flash(_('Meanwhile, the following reviewers have been removed: %s') %
                     (', '.join(u.username for u in other_removed)),
                     category='warning')
 
@@ -418,28 +418,28 b' class PullrequestsController(BaseRepoCon'
         old_description = pull_request.description
         pull_request.title = _form['pullrequest_title']
         pull_request.description = _form['pullrequest_desc'].strip() or _('No description')
-        pull_request.owner = User.get_by_username(_form['owner'])
-        user = User.get(request.authuser.user_id)
+        pull_request.owner = db.User.get_by_username(_form['owner'])
+        user = db.User.get(request.authuser.user_id)
 
         PullRequestModel().mention_from_description(user, pull_request, old_description)
         PullRequestModel().add_reviewers(user, pull_request, added_reviewers)
         PullRequestModel().remove_reviewers(user, pull_request, removed_reviewers)
 
-        Session().commit()
-        h.flash(_('Pull request updated'), category='success')
+        meta.Session().commit()
+        webutils.flash(_('Pull request updated'), category='success')
 
         raise HTTPFound(location=pull_request.url())
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def delete(self, repo_name, pull_request_id):
-        pull_request = PullRequest.get_or_404(pull_request_id)
+        pull_request = db.PullRequest.get_or_404(pull_request_id)
         # only owner can delete it !
         if pull_request.owner_id == request.authuser.user_id:
             PullRequestModel().delete(pull_request)
-            Session().commit()
-            h.flash(_('Successfully deleted pull request'),
+            meta.Session().commit()
+            webutils.flash(_('Successfully deleted pull request'),
                     category='success')
             raise HTTPFound(location=url('my_pullrequests'))
         raise HTTPForbidden()
@@ -447,7 +447,7 b' class PullrequestsController(BaseRepoCon'
     @LoginRequired(allow_default_user=True)
     @HasRepoPermissionLevelDecorator('read')
     def show(self, repo_name, pull_request_id, extra=None):
-        c.pull_request = PullRequest.get_or_404(pull_request_id)
+        c.pull_request = db.PullRequest.get_or_404(pull_request_id)
         c.allowed_to_change_status = self._is_allowed_to_change_status(c.pull_request)
         cc_model = ChangesetCommentsModel()
         cs_model = ChangesetStatusModel()
@@ -475,7 +475,7 b' class PullrequestsController(BaseRepoCon'
                 c.cs_ranges.append(org_scm_instance.get_changeset(x))
             except ChangesetDoesNotExistError:
                 c.cs_ranges = []
-                h.flash(_('Revision %s not found in %s') % (x, c.cs_repo.repo_name),
+                webutils.flash(_('Revision %s not found in %s') % (x, c.cs_repo.repo_name),
                     'error')
                 break
         c.cs_ranges_org = None # not stored and not important and moving target - could be calculated ...
@@ -553,7 +553,7 b' class PullrequestsController(BaseRepoCon'
                         show.update(org_scm_instance._repo.revs('::%ld - ::%ld - ::%s', brevs, avail_revs, c.a_branch_name))
                         show.add(revs[0]) # make sure graph shows this so we can see how they relate
                         c.update_msg_other = _('Note: Branch %s has another head: %s.') % (c.cs_branch_name,
-                            h.short_id(org_scm_instance.get_changeset((max(brevs))).raw_id))
+                            org_scm_instance.get_changeset(max(brevs)).short_id)
 
                     avail_show = sorted(show, reverse=True)
 
@@ -571,10 +571,8 b' class PullrequestsController(BaseRepoCon'
         c.cs_comments = c.cs_repo.get_comments(raw_ids)
         c.cs_statuses = c.cs_repo.statuses(raw_ids)
 
-        ignore_whitespace = request.GET.get('ignorews') == '1'
-        line_context = safe_int(request.GET.get('context'), 3)
-        c.ignorews_url = _ignorews_url
-        c.context_url = _context_url
+        ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)
+        diff_context_size = h.get_diff_context_size(request.GET)
         fulldiff = request.GET.get('fulldiff')
         diff_limit = None if fulldiff else self.cut_off_limit
 
@@ -583,7 +581,7 b' class PullrequestsController(BaseRepoCon'
                   c.a_rev, c.cs_rev, org_scm_instance.path)
         try:
             raw_diff = diffs.get_diff(org_scm_instance, rev1=c.a_rev, rev2=c.cs_rev,
-                                      ignore_whitespace=ignore_whitespace, context=line_context)
+                                      ignore_whitespace=ignore_whitespace_diff, context=diff_context_size)
         except ChangesetDoesNotExistError:
             raw_diff = safe_bytes(_("The diff can't be shown - the PR revisions could not be found."))
         diff_processor = diffs.DiffProcessor(raw_diff, diff_limit=diff_limit)
@@ -598,7 +596,7 b' class PullrequestsController(BaseRepoCon'
             c.lines_deleted += st['deleted']
             filename = f['filename']
             fid = h.FID('', filename)
-            html_diff = diffs.as_html(enable_comments=True, parsed_lines=[f])
+            html_diff = diffs.as_html(parsed_lines=[f])
             c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))
 
         # inline comments
@@ -618,23 +616,23 b' class PullrequestsController(BaseRepoCon'
          c.pull_request_pending_reviewers,
          c.current_voting_result,
          ) = cs_model.calculate_pull_request_result(c.pull_request)
-        c.changeset_statuses = ChangesetStatus.STATUSES
+        c.changeset_statuses = db.ChangesetStatus.STATUSES
 
         c.is_ajax_preview = False
         c.ancestors = None # [c.a_rev] ... but that is shown in an other way
-        return render('/pullrequests/pullrequest_show.html')
+        return base.render('/pullrequests/pullrequest_show.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def comment(self, repo_name, pull_request_id):
-        pull_request = PullRequest.get_or_404(pull_request_id)
+        pull_request = db.PullRequest.get_or_404(pull_request_id)
         allowed_to_change_status = self._is_allowed_to_change_status(pull_request)
         return create_cs_pr_comment(repo_name, pull_request=pull_request,
                 allowed_to_change_status=allowed_to_change_status)
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def delete_comment(self, repo_name, comment_id):
         return delete_cs_pr_comment(repo_name, comment_id)

kallithea/controllers/root.py

@@ -14,9 +14,9 b''
 from tg import config
 from tgext.routes import RoutedController
 
-from kallithea.config.routing import make_map
+from kallithea.controllers import base
 from kallithea.controllers.error import ErrorController
-from kallithea.lib.base import BaseController
+from kallithea.controllers.routing import make_map
 
 
 # This is the main Kallithea entry point; TurboGears will forward all requests
@@ -26,7 +26,7 b' from kallithea.lib.base import BaseContr'
 # The mapper is configured using routes defined in routing.py.  This use of the
 # 'mapper' attribute is a feature of tgext.routes, which is activated by
 # inheriting from its RoutedController class.
-class RootController(RoutedController, BaseController):
+class RootController(RoutedController, base.BaseController):
 
     def __init__(self):
         self.mapper = make_map(config)

kallithea/controllers/routing.py

@@ -20,15 +20,12 b' refer to the routes manual at http://rou'
 """
 
 import routes
-from tg import request
 
+import kallithea
+from kallithea.lib.utils import is_valid_repo, is_valid_repo_group
 from kallithea.lib.utils2 import safe_str
 
 
-# prefix for non repository related links needs to be prefixed with `/`
-ADMIN_PREFIX = '/_admin'
-
-
 class Mapper(routes.Mapper):
     """
     Subclassed Mapper with routematch patched to decode "unicode" str url to
@@ -54,8 +51,6 b' def make_map(config):'
     rmap.minimization = False
     rmap.explicit = False
 
-    from kallithea.lib.utils import is_valid_repo, is_valid_repo_group
-
     def check_repo(environ, match_dict):
         """
         Check for valid repository for proper 404 handling.
@@ -121,6 +116,7 b' def make_map(config):'
     rmap.connect('issues_url', 'https://bitbucket.org/conservancy/kallithea/issues', _static=True)
 
     # ADMIN REPOSITORY ROUTES
+    ADMIN_PREFIX = kallithea.ADMIN_PREFIX
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repos') as m:
         m.connect("repos", "/repos",
@@ -775,29 +771,3 b' def make_map(config):'
                  conditions=dict(function=check_repo))
 
     return rmap
-
-
-class UrlGenerator(object):
-    """Emulate pylons.url in providing a wrapper around routes.url
-
-    This code was added during migration from Pylons to Turbogears2. Pylons
-    already provided a wrapper like this, but Turbogears2 does not.
-
-    When the routing of Kallithea is changed to use less Routes and more
-    Turbogears2-style routing, this class may disappear or change.
-
-    url() (the __call__ method) returns the URL based on a route name and
-    arguments.
-    url.current() returns the URL of the current page with arguments applied.
-
-    Refer to documentation of Routes for details:
-    https://routes.readthedocs.io/en/latest/generating.html#generation
-    """
-    def __call__(self, *args, **kwargs):
-        return request.environ['routes.url'](*args, **kwargs)
-
-    def current(self, *args, **kwargs):
-        return request.environ['routes.url'].current(*args, **kwargs)
-
-
-url = UrlGenerator()

kallithea/controllers/search.py

@@ -35,8 +35,8 b' from whoosh.index import EmptyIndexError'
 from whoosh.qparser import QueryParser, QueryParserError
 from whoosh.query import Phrase, Prefix
 
+from kallithea.controllers import base
 from kallithea.lib.auth import LoginRequired
-from kallithea.lib.base import BaseRepoController, render
 from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA, WhooshResultWrapper
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int
@@ -46,7 +46,7 b' from kallithea.model.repo import RepoMod'
 log = logging.getLogger(__name__)
 
 
-class SearchController(BaseRepoController):
+class SearchController(base.BaseRepoController):
 
     @LoginRequired(allow_default_user=True)
     def index(self, repo_name=None):
@@ -139,4 +139,4 b' class SearchController(BaseRepoControlle'
                 c.runtime = _('An error occurred during search operation.')
 
         # Return a rendered template
-        return render('/search/search.html')
+        return base.render('/search/search.html')

kallithea/controllers/summary.py

@@ -38,19 +38,17 b' from tg import tmpl_context as c'
 from tg.i18n import ugettext as _
 from webob.exc import HTTPBadRequest
 
-import kallithea.lib.helpers as h
-from kallithea.config.conf import ALL_EXTS, ALL_READMES, LANGUAGES_EXTENSIONS_MAP
-from kallithea.lib import ext_json
+from kallithea.controllers import base
+from kallithea.lib import ext_json, webutils
 from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired
-from kallithea.lib.base import BaseRepoController, jsonify, render
-from kallithea.lib.celerylib.tasks import get_commits_stats
+from kallithea.lib.conf import ALL_EXTS, ALL_READMES, LANGUAGES_EXTENSIONS_MAP
 from kallithea.lib.markup_renderer import MarkupRenderer
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int, safe_str
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, NodeDoesNotExistError
 from kallithea.lib.vcs.nodes import FileNode
-from kallithea.model.db import Statistics
+from kallithea.model import async_tasks, db
 
 
 log = logging.getLogger(__name__)
@@ -60,7 +58,7 b" README_FILES = [''.join([x[0][0], x[1][0"
                            key=lambda y:y[0][1] + y[1][1])]
 
 
-class SummaryController(BaseRepoController):
+class SummaryController(base.BaseRepoController):
 
     def __get_readme_data(self, db_repo):
         repo_name = db_repo.repo_name
@@ -108,7 +106,7 b' class SummaryController(BaseRepoControll'
         try:
             collection = c.db_repo_scm_instance.get_changesets(reverse=True)
         except EmptyRepositoryError as e:
-            h.flash(e, category='warning')
+            webutils.flash(e, category='warning')
             collection = []
         c.cs_pagination = Page(collection, page=p, items_per_page=size)
         page_revisions = [x.raw_id for x in list(c.cs_pagination)]
@@ -131,8 +129,8 b' class SummaryController(BaseRepoControll'
         else:
             c.show_stats = False
 
-        stats = Statistics.query() \
-            .filter(Statistics.repository == c.db_repo) \
+        stats = db.Statistics.query() \
+            .filter(db.Statistics.repository == c.db_repo) \
             .scalar()
 
         c.stats_percentage = 0
@@ -150,11 +148,11 b' class SummaryController(BaseRepoControll'
         c.enable_downloads = c.db_repo.enable_downloads
         c.readme_data, c.readme_file = \
             self.__get_readme_data(c.db_repo)
-        return render('summary/summary.html')
+        return base.render('summary/summary.html')
 
     @LoginRequired()
     @HasRepoPermissionLevelDecorator('read')
-    @jsonify
+    @base.jsonify
     def repo_size(self, repo_name):
         if request.is_xhr:
             return c.db_repo._repo_size()
@@ -181,8 +179,8 b' class SummaryController(BaseRepoControll'
         c.ts_min = ts_min_m
         c.ts_max = ts_max_y
 
-        stats = Statistics.query() \
-            .filter(Statistics.repository == c.db_repo) \
+        stats = db.Statistics.query() \
+            .filter(db.Statistics.repository == c.db_repo) \
             .scalar()
         c.stats_percentage = 0
         if stats and stats.languages:
@@ -210,5 +208,5 b' class SummaryController(BaseRepoControll'
             c.trending_languages = []
 
         recurse_limit = 500  # don't recurse more than 500 times when parsing
-        get_commits_stats(c.db_repo.repo_name, ts_min_y, ts_max_y, recurse_limit)
-        return render('summary/statistics.html')
+        async_tasks.get_commits_stats(c.db_repo.repo_name, ts_min_y, ts_max_y, recurse_limit)
+        return base.render('summary/statistics.html')

kallithea/front-end/kallithea-diff.less

@@ -62,6 +62,7 b' BIN_FILENODE = 6'
   border-collapse: collapse;
   border-radius: 0px !important;
   width: 100%;
+  table-layout: fixed;
 
   /* line coloring */
   .context {
@@ -105,31 +106,26 b' BIN_FILENODE = 6'
     border-color: rgba(0, 0, 0, 0.3);
   }
 
-  /* line numbers */
-  .lineno {
-    padding-left: 2px;
-    padding-right: 2px !important;
-    width: 30px;
+  /* line number columns */
+  td.lineno {
+    width: 4em;
     border-right: 1px solid @panel-default-border !important;
     vertical-align: middle !important;
-    text-align: center;
-  }
-  .lineno.new {
-    text-align: right;
-  }
-  .lineno.old {
-    text-align: right;
-  }
-  .lineno a {
-    color: #aaa !important;
     font-size: 11px;
     font-family: @font-family-monospace;
     line-height: normal;
-    padding-left: 6px;
-    padding-right: 6px;
-    display: block;
+    text-align: center;
+  }
+  td.lineno[colspan="2"] {
+    width: 8em;
   }
-  .line:hover .lineno a {
+  td.lineno a {
+    color: #aaa !important;
+    display: inline-block;
+    min-width: 2em;
+    text-align: right;
+  }
+  tr.line:hover td.lineno a {
     color: #333 !important;
   }
   /** CODE **/
@@ -172,27 +168,24 b' BIN_FILENODE = 6'
   left: -8px;
   box-sizing: border-box;
 }
-/* comment bubble, only visible when in a commentable diff */
-.commentable-diff tr.line.add:hover td .add-bubble,
-.commentable-diff tr.line.del:hover td .add-bubble,
-.commentable-diff tr.line.unmod:hover td .add-bubble {
+.commentable-diff tr.line:hover td .add-bubble {
   display: block;
   z-index: 1;
 }
 .add-bubble div {
   background: @kallithea-theme-main-color;
-  width: 16px;
-  height: 16px;
-  line-height: 14px;
+  width: 1.2em;
+  height: 1.2em;
+  line-height: 1em;
   cursor: pointer;
-  padding: 0 2px 2px 0.5px;
+  padding: 0.1em 0.1em 0.1em 0.12em;
   border: 1px solid @kallithea-theme-main-color;
-  border-radius: 3px;
+  border-radius: 0.2em;
   box-sizing: border-box;
   overflow: hidden;
 }
 .add-bubble div:before {
-  font-size: 14px;
+  font-size: 1em;
   color: #ffffff;
   font-family: "kallithea";
   content: '\1f5ea';

kallithea/front-end/style.less

@@ -564,10 +564,6 b' input.status_change_radio {'
     background-position: 20px 0;
   }
 }
-.comment-preview.failed .user,
-.comment-preview.failed .panel-body {
-  color: #666;
-}
 .comment-preview .comment-submission-status {
   float: right;
 }

kallithea/i18n/be/LC_MESSAGES/kallithea.po

@@ -11,24 +11,21 b' msgstr ""'
 "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
 
+msgid "Repository not found in the filesystem"
+msgstr "Рэпазітар не знойдзены на файлавай сістэме"
+
 msgid "There are no changesets yet"
 msgstr "Яшчэ не было змен"
 
+msgid "Changeset for %s %s not found in %s"
+msgstr "Набор змен для %s %s не знойдзены ў %s"
+
 msgid "None"
 msgstr "Нічога"
 
 msgid "(closed)"
 msgstr "(зачынена)"
 
-msgid "Show whitespace"
-msgstr "Паказваць прабелы"
-
-msgid "Ignore whitespace"
-msgstr "Ігнараваць прабелы"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Павялічыць кантэкст да %(num)s радкоў"
-
 msgid "Successfully deleted pull request %s"
 msgstr "Pull-запыт %s паспяхова выдалены"
 
@@ -462,13 +459,6 b' msgstr "\xd0\x90\xd0\xb4\xd0\xb1\xd1\x8b\xd0\xbb\xd0\xb0\xd1\x81\xd1\x8f \xd0\xbf\xd0\xb0\xd0\xbc\xd1\x8b\xd0\xbb\xd0\xba\xd0\xb0 \xd0\xbf\xd1\x80\xd1\x8b \xd0\xb2\xd1\x8b\xd0\xb4\xd0\xb0\xd0\xbb\xd0\xb5\xd0\xbd\xd0\xbd\xd1\x96 \xd1\x81\xd1\x82\xd0\xb0\xd1\x82\xd1\x8b\xd1\x81\xd1\x82\xd1\x8b\xd0\xba\xd1\x96 \xd1\x80\xd1\x8d\xd0\xbf\xd0\xb0\xd0\xb7\xd1\x96\xd1\x82\xd0\xb0\xd1\x80\xd0\xb0"'
 msgid "Updated VCS settings"
 msgstr "Абноўлены налады VCS"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"Немагчыма ўключыць падтрымку hgsubversion. Бібліятэка hgsubversion "
-"адсутнічае"
-
 msgid "Error occurred while updating application settings"
 msgstr "Памылка пры абнаўленні наладаў праграмы"
 
@@ -566,12 +556,6 b' msgstr ""'
 msgid "You need to be signed in to view this page"
 msgstr "Старонка даступная толькі аўтарызаваным карыстальнікам"
 
-msgid "Repository not found in the filesystem"
-msgstr "Рэпазітар не знойдзены на файлавай сістэме"
-
-msgid "Changeset for %s %s not found in %s"
-msgstr "Набор змен для %s %s не знойдзены ў %s"
-
 msgid "Binary file"
 msgstr "Двайковы файл"
 
@@ -584,6 +568,9 b' msgstr ""'
 msgid "No changes detected"
 msgstr "Змен не выяўлена"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Павялічыць кантэкст да %(num)s радкоў"
+
 msgid "Deleted branch: %s"
 msgstr "Выдаленая галіна: %s"
 
@@ -695,15 +682,6 b' msgstr "\xd0\xbf\xd0\xb5\xd1\x80\xd0\xb0\xd0\xbd\xd0\xb0\xd0\xb7\xd0\xb2\xd0\xb0\xd0\xbd\xd1\x8b"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"Рэпазітар %s адсутнічае ў базе дадзеных; магчыма, ён быў створаны ці "
-"пераназваны з файлавай сістэмы. Калі ласка, перазапусціце прыкладанне для "
-"сканавання рэпазітароў"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d год"
@@ -755,24 +733,12 b' msgstr "%s \xd1\x96 %s \xd0\xbd\xd0\xb0\xd0\xb7\xd0\xb0\xd0\xb4"'
 msgid "just now"
 msgstr "цяпер"
 
-msgid "on line %s"
-msgstr "на радку %s"
-
-msgid "[Mention]"
-msgstr "[Згадванне]"
-
 msgid "top level"
 msgstr "верхні ўзровень"
 
 msgid "Kallithea Administrator"
 msgstr "Адміністратар Kallithea"
 
-msgid "Only admins can create repository groups"
-msgstr "Толькі адміністратары могуць ствараць групы репазітароў"
-
-msgid "Non-admins can create repository groups"
-msgstr "Неадміністратары могуць ствараць групы репазітароў"
-
 msgid "Only admins can create user groups"
 msgstr "Толькі адміністратары могуць ствараць групы карыстальнікаў"
 
@@ -827,17 +793,9 b' msgstr "\xd0\x9d\xd0\xbe\xd0\xb2\xd1\x8b \xd0\xba\xd0\xb0\xd1\x80\xd1\x8b\xd1\x81\xd1\x82\xd0\xb0\xd0\xbb\xd1\x8c\xd0\xbd\xd1\x96\xd0\xba \\"%(new_username)s\\" \xd0\xb7\xd0\xb0\xd1\x80\xd1\x8d\xd0\xb3\xd1\x96\xd1\x81\xd1\x82\xd1\x80\xd0\xb0\xd0\xb2\xd0\xb0\xd0\xbd\xd1\x8b"'
 msgid "Closing"
 msgstr "Зачынены"
 
-msgid ""
-"%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
-msgstr ""
-"%(user)s просіць вас разгледзець pull request %(pr_nice_id)s: %(pr_title)s"
-
 msgid "latest tip"
 msgstr "апошняя версія"
 
-msgid "New user registration"
-msgstr "Рэгістрацыя новага карыстальніка"
-
 msgid ""
 "You can't remove this user since it is crucial for the entire application"
 msgstr ""
@@ -944,13 +902,6 b' msgstr "\xd0\x93\xd1\x80\xd1\x83\xd0\xbf\xd0\xb0 \xd1\x80\xd1\x8d\xd0\xbf\xd0\xb0\xd0\xb7\xd1\x96\xd1\x82\xd0\xb0\xd1\x80\xd0\xbe\xd1\x9e \\"%(repo)s\\" \xd1\x83\xd0\xb6\xd0\xbe \xd1\x96\xd1\x81\xd0\xbd\xd1\x83\xd0\xb5"'
 msgid "Invalid repository URL"
 msgstr "Няслушны URL рэпазітара"
 
-msgid ""
-"Invalid repository URL. It must be a valid http, https, ssh, svn+http or "
-"svn+https URL"
-msgstr ""
-"Няслушны URL рэпазітара. Ён мусіць быць карэктным URL http, https, ssh, "
-"svn+http ці svn+https"
-
 msgid "Fork has to be the same type as parent"
 msgstr "Тып форка будзе супадаць з бацькоўскім"
 
@@ -1042,10 +993,10 b' msgstr "\xd0\x86\xd0\xbc\xd1\x8f \xd0\xba\xd0\xb0\xd1\x80\xd1\x8b\xd1\x81\xd1\x82\xd0\xb0\xd0\xbb\xd1\x8c\xd0\xbd\xd1\x96\xd0\xba\xd0\xb0"'
 msgid "Password"
 msgstr "Пароль"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "Забыліся на пароль?"
 
-msgid "Don't have an account ?"
+msgid "Don't have an account?"
 msgstr "Няма акаўнта?"
 
 msgid "Sign In"
@@ -1627,9 +1578,6 b' msgstr "\xd0\x9f\xd1\x80\xd1\x8b\xd0\xb2\xd1\x96\xd1\x82\xd0\xb0\xd0\xbd\xd0\xbd\xd0\xb5 \xd0\xb4\xd0\xbb\xd1\x8f HTTP-\xd0\xb0\xd1\x9e\xd1\x82\xd1\x8d\xd0\xbd\xd1\x82\xd1\x8b\xd1\x84\xd1\x96\xd0\xba\xd0\xb0\xd1\x86\xd1\x8b\xd1\x96"'
 msgid "Save Settings"
 msgstr "Захаваць налады"
 
-msgid "Custom Hooks"
-msgstr "Карыстальніцкія хукі"
-
 msgid "Failed to remove hook"
 msgstr "Не атрымалася выдаліць хук"
 
@@ -1675,9 +1623,6 b' msgstr "\xd0\x9f\xd0\xb0\xd1\x88\xd1\x8b\xd1\x80\xd1\x8d\xd0\xbd\xd0\xbd\xd1\x96 Mercurial"'
 msgid "Enable largefiles extension"
 msgstr "Уключыць падтрымку вялікіх файлаў"
 
-msgid "Enable hgsubversion extension"
-msgstr "Уключыць падтрымку hgsubversion"
-
 msgid "Location of repositories"
 msgstr "Месцазнаходжанне рэпазітароў"
 
@@ -1967,8 +1912,8 b' msgstr "\xd0\x9d\xd1\x8f\xd0\xbc\xd0\xb0 \xd1\x80\xd1\x8d\xd0\xb2\xd1\x96\xd0\xb7\xd1\x96\xd0\xb9"'
 msgid "Failed to revoke permission"
 msgstr "Не атрымалася адклікаць прывілеі"
 
-msgid "Confirm to revoke permission for {0}: {1} ?"
-msgstr "Пацвердзіце выдаленне прывілею для {0}: {1} ?"
+msgid "Confirm to revoke permission for {0}: {1}?"
+msgstr "Пацвердзіце выдаленне прывілею для {0}: {1}?"
 
 msgid "Select changeset"
 msgstr "Выбраць набор змен"
@@ -2214,6 +2159,9 b' msgstr "\xd0\x9c\xd1\x8b \xd0\xb0\xd1\x82\xd1\x80\xd1\x8b\xd0\xbc\xd0\xb0\xd0\xbb\xd1\x96 \xd0\xb7\xd0\xb0\xd0\xbf\xd1\x8b\xd1\x82 \xd0\xbd\xd0\xb0 \xd1\x81\xd0\xba\xd1\x96\xd0\xb4\xd0\xb0\xd0\xbd\xd0\xbd\xd0\xb5 \xd0\xbf\xd0\xb0\xd1\x80\xd0\xbe\xd0\xbb\xd1\x8f \xd0\xb4\xd0\xbb\xd1\x8f \xd0\xb2\xd0\xb0\xd1\x88\xd0\xb0\xd0\xb3\xd0\xb0 \xd0\xb0\xd0\xba\xd0\xb0\xd1\x9e\xd0\xbd\xd1\x82\xd0\xb0."'
 msgid "File diff"
 msgstr "Параўнанне файлаў"
 
+msgid "Ignore whitespace"
+msgstr "Ігнараваць прабелы"
+
 msgid "%s File Diff"
 msgstr "Параўнанне файла %s"
 

kallithea/i18n/da/LC_MESSAGES/kallithea.po

@@ -10,24 +10,25 b' msgstr ""'
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
 
+msgid ""
+"CSRF token leak has been detected - all form tokens have been expired"
+msgstr "CSRF-token lækage opdaget, alle form-tokens er invalideret"
+
+msgid "Repository not found in the filesystem"
+msgstr "Repository ikke fundet i filsystemet"
+
 msgid "There are no changesets yet"
 msgstr "Der er ingen changesets endnu"
 
+msgid "Changeset for %s %s not found in %s"
+msgstr "Changeset for %s %s ikke fundet i %s"
+
 msgid "None"
 msgstr "Ingen"
 
 msgid "(closed)"
 msgstr "(lukket)"
 
-msgid "Show whitespace"
-msgstr "Vis mellemrum"
-
-msgid "Ignore whitespace"
-msgstr "Ignorer mellemrum"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Øg diff konteksten med %(num)s linjer"
-
 msgid "Successfully deleted pull request %s"
 msgstr "Pull-forespørgsel %s slettet successfuldt"
 
@@ -495,13 +496,6 b' msgstr "Der opstod en fejl under sletnin'
 msgid "Updated VCS settings"
 msgstr "Opdateret VCS-indstillinger"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"Ude af stand til at aktivere hgsubversion understøttelse. \"hgsubversion"
-"\" biblioteket mangler"
-
 msgid "Error occurred while updating application settings"
 msgstr "Der opstod en fejl ved opdatering af applikationsindstillinger"
 
@@ -598,16 +592,6 b' msgstr "Du skal v\xc3\xa6re registreret bruger for at kunne udf\xc3\xb8re denne handling"'
 msgid "You need to be signed in to view this page"
 msgstr "Du skal være logget ind for at se denne side"
 
-msgid ""
-"CSRF token leak has been detected - all form tokens have been expired"
-msgstr "CSRF-token lækage opdaget, alle form-tokens er invalideret"
-
-msgid "Repository not found in the filesystem"
-msgstr "Repository ikke fundet i filsystemet"
-
-msgid "Changeset for %s %s not found in %s"
-msgstr "Changeset for %s %s ikke fundet i %s"
-
 msgid "Binary file"
 msgstr "Binær fil"
 
@@ -620,6 +604,9 b' msgstr ""'
 msgid "No changes detected"
 msgstr "Ingen ændringer fundet"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Øg diff konteksten med %(num)s linjer"
+
 msgid "Deleted branch: %s"
 msgstr "Slettet branch: %s"
 
@@ -731,14 +718,6 b' msgstr "omd\xc3\xb8b"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"%s repository er ikke knyttet til db, måske var det skabt eller omdøbt "
-"fra filsystemet, kør applikationen igen for at scanne repositories"
-
 msgid "in %s"
 msgstr "i %s"
 
@@ -754,12 +733,6 b' msgstr "%s og %s siden"'
 msgid "just now"
 msgstr "lige nu"
 
-msgid "on line %s"
-msgstr "på linje %s"
-
-msgid "[Mention]"
-msgstr "[Omtale]"
-
 msgid "top level"
 msgstr "top-niveau"
 
@@ -802,12 +775,6 b' msgstr "Standard-bruger har skrive-adgan'
 msgid "Default user has admin access to new user groups"
 msgstr "Standard-bruger har admin-adgang til nye brugergrupper"
 
-msgid "Only admins can create repository groups"
-msgstr "Kun administratorer kan oprette repository-grupper"
-
-msgid "Non-admins can create repository groups"
-msgstr "Ikke-administratorer kan oprette repository-grupper"
-
 msgid "Only admins can create user groups"
 msgstr "Kun administratorer kan oprette brugergrupper"
 
@@ -820,17 +787,6 b' msgstr "Kun administratorer kan oprette '
 msgid "Non-admins can create top level repositories"
 msgstr "Ikke-administratorer kan oprette top-niveau repositories"
 
-msgid ""
-"Repository creation enabled with write permission to a repository group"
-msgstr ""
-"Repository oprettelse aktiveret med skriveadgang til en repository-gruppe"
-
-msgid ""
-"Repository creation disabled with write permission to a repository group"
-msgstr ""
-"Repository oprettelse deaktiveret med skriveadgang til en repository-"
-"gruppe"
-
 msgid "Only admins can fork repositories"
 msgstr "Kun admins kan fork repositories"
 
@@ -873,13 +829,6 b' msgstr "Indtast %(min)i tegn eller flere'
 msgid "Name must not contain only digits"
 msgstr "Navn må ikke kun indeholde cifre"
 
-msgid ""
-"[Comment] %(repo_name)s changeset %(short_id)s \"%(message_short)s\" on "
-"%(branch)s"
-msgstr ""
-"[Kommentar] %(repo_name)s changeset %(short_id)s \"%(message_short)s\" på "
-"%(branch)s"
-
 msgid "New user %(new_username)s registered"
 msgstr "Ny bruger %(new_username)s registreret"
 
@@ -900,11 +849,8 b' msgstr ""'
 msgid "Closing"
 msgstr "Lukning"
 
-msgid ""
-"%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
-msgstr ""
-"%(user)s vil have dig til at gennemgå pull-forespørgsel %(pr_nice_id)s: "
-"%(pr_title)s"
-
 msgid "Cannot create empty pull request"
 msgstr "Kan ikke oprette en tom pull-forespørgsel"
+
+msgid "Ignore whitespace"
+msgstr "Ignorer mellemrum"

kallithea/i18n/de/LC_MESSAGES/kallithea.po

@@ -10,6 +10,14 b' msgstr ""'
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
 
+msgid ""
+"CSRF token leak has been detected - all form tokens have been expired"
+msgstr ""
+"Es wurde ein CSRF Leck entdeckt. Alle Formular Token sind abgelaufen"
+
+msgid "Repository not found in the filesystem"
+msgstr "Das Repository konnte nicht im Filesystem gefunden werden"
+
 msgid "There are no changesets yet"
 msgstr "Es gibt noch keine Änderungssätze"
 
@@ -19,15 +27,6 b' msgstr "Keine"'
 msgid "(closed)"
 msgstr "(geschlossen)"
 
-msgid "Show whitespace"
-msgstr "Zeige unsichtbare Zeichen"
-
-msgid "Ignore whitespace"
-msgstr "Ignoriere unsichtbare Zeichen"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Erhöhe diff-Kontext auf %(num)s Zeilen"
-
 msgid "Successfully deleted pull request %s"
 msgstr "Pull-Request %s erfolgreich gelöscht"
 
@@ -486,13 +485,6 b' msgstr "W\xc3\xa4hrend des l\xc3\xb6schens der Repository Statistiken trat ein Fehler auf"'
 msgid "Updated VCS settings"
 msgstr "VCS-Einstellungen aktualisiert"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"hgsubversion-Unterstützung konnte nicht aktiviert werden. Die "
-"\"hgsubversion\"-Bibliothek fehlt"
-
 msgid "Error occurred while updating application settings"
 msgstr ""
 "Ein Fehler ist während der Aktualisierung der Applikationseinstellungen "
@@ -520,11 +512,6 b' msgstr "Bitte geben Sie eine E-Mail-Adre'
 msgid "Send email task created"
 msgstr "Task zum Versenden von E-Mails erstellt"
 
-msgid "Builtin hooks are read-only. Please use another hook name."
-msgstr ""
-"Die eingebauten Hooks sind schreibgeschützt. Bitte verwenden Sie einen "
-"anderen Hook-Namen."
-
 msgid "Added new hook"
 msgstr "Neuer Hook hinzugefügt"
 
@@ -604,14 +591,6 b' msgstr ""'
 msgid "You need to be signed in to view this page"
 msgstr "Sie müssen sich anmelden um diese Seite aufzurufen"
 
-msgid ""
-"CSRF token leak has been detected - all form tokens have been expired"
-msgstr ""
-"Es wurde ein CSRF Leck entdeckt. Alle Formular Token sind abgelaufen"
-
-msgid "Repository not found in the filesystem"
-msgstr "Das Repository konnte nicht im Filesystem gefunden werden"
-
 msgid "Binary file"
 msgstr "Binäre Datei"
 
@@ -624,6 +603,9 b' msgstr ""'
 msgid "No changes detected"
 msgstr "Keine Änderungen erkannt"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Erhöhe diff-Kontext auf %(num)s Zeilen"
+
 msgid "Deleted branch: %s"
 msgstr "Branch %s gelöscht"
 
@@ -732,15 +714,6 b' msgstr "umbenennen"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"Das %s Repository ist nicht in der Datenbank vorhanden, eventuell wurde "
-"es im Dateisystem erstellt oder umbenannt. Bitte starten sie die "
-"Applikation erneut um die Repositories neu zu Indizieren"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d Jahr"
@@ -786,12 +759,6 b' msgstr "%s und %s her"'
 msgid "just now"
 msgstr "jetzt gerade"
 
-msgid "on line %s"
-msgstr "in Zeile %s"
-
-msgid "[Mention]"
-msgstr "[Mention]"
-
 msgid "top level"
 msgstr "höchste Ebene"
 
@@ -835,12 +802,6 b' msgstr "Der Standard-Benutzer hat Schrei'
 msgid "Default user has admin access to new user groups"
 msgstr "Der Standard-Benutzer hat Admin-Rechte auf neuen Benutzer-Gruppen"
 
-msgid "Only admins can create repository groups"
-msgstr "Nur Admins können Repository-Gruppen erstellen"
-
-msgid "Non-admins can create repository groups"
-msgstr "Nicht-Admins können Repository-Gruppen erstellen"
-
 msgid "Only admins can create user groups"
 msgstr "Nur Admins können Benutzer-Gruppen erstellen"
 
@@ -853,18 +814,6 b' msgstr "Nur Admins k\xc3\xb6nnen Repositories auf oberster Ebene erstellen"'
 msgid "Non-admins can create top level repositories"
 msgstr "Nicht-Admins können Repositories oberster Ebene erstellen"
 
-msgid ""
-"Repository creation enabled with write permission to a repository group"
-msgstr ""
-"Erstellung von Repositories mit Schreibzugriff für Repositorygruppe "
-"aktiviert"
-
-msgid ""
-"Repository creation disabled with write permission to a repository group"
-msgstr ""
-"Erstellung von Repositories mit Schreibzugriff für Repositorygruppe "
-"deaktiviert"
-
 msgid "Only admins can fork repositories"
 msgstr "Nur Admins können Repositories forken"
 
@@ -926,9 +875,6 b' msgstr "Geschlossen, n\xc3\xa4chste Iteration: %s ."'
 msgid "latest tip"
 msgstr "Letzter Tip"
 
-msgid "New user registration"
-msgstr "Neue Benutzerregistrierung"
-
 msgid ""
 "User \"%s\" still owns %s repositories and cannot be removed. Switch "
 "owners or remove those repositories: %s"
@@ -1021,13 +967,6 b' msgstr "Eine Repositorygruppe mit dem Na'
 msgid "Invalid repository URL"
 msgstr "Ungültige Repository-URL"
 
-msgid ""
-"Invalid repository URL. It must be a valid http, https, ssh, svn+http or "
-"svn+https URL"
-msgstr ""
-"Ungültige Repository-URL. Es muss eine gültige http, https, ssh, svn+http "
-"oder svn+https URL sein"
-
 msgid "Fork has to be the same type as parent"
 msgstr "Forke um den selben typ wie der Vorgesetze zu haben"
 
@@ -1129,10 +1068,10 b' msgstr "Passwort"'
 msgid "Stay logged in after browser restart"
 msgstr "Nach dem Neustart des Browsers eingeloggt bleiben"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "Passwort vergessen?"
 
-msgid "Don't have an account ?"
+msgid "Don't have an account?"
 msgstr "Kein Account?"
 
 msgid "Sign In"
@@ -1566,25 +1505,6 b' msgstr ""'
 "Aktiviere dies, damit Nicht-Administratoren Repositories auf der obersten "
 "Ebene erstellen können."
 
-msgid ""
-"Note: This will also give all users API access to create repositories "
-"everywhere. That might change in future versions."
-msgstr ""
-"Hinweis: dadurch erhalten auch alle Benutzer API-Zugriff, um überall "
-"Repositories zu erstellen. Das kann sich in zukünftigen Versionen ändern."
-
-msgid "Repository creation with group write access"
-msgstr "Repository-Erstellung mit Gruppen-Schreibzugriff"
-
-msgid ""
-"With this, write permission to a repository group allows creating "
-"repositories inside that group. Without this, group write permissions "
-"mean nothing."
-msgstr ""
-"Falls aktiv, gewährt dies das Recht zum Erzeugen von Repositories in "
-"einer Repository-Gruppe. Falls inaktiv, sind Gruppen-"
-"Schreibberechtigungen wirkungslos."
-
 msgid "User group creation"
 msgstr "Benutzergruppen Erstellung"
 
@@ -1988,12 +1908,6 b' msgstr ""'
 msgid "Save Settings"
 msgstr "Einstellungen speichern"
 
-msgid "Built-in Mercurial Hooks (Read-Only)"
-msgstr "Eingebaute Mercurial Hooks (Read -Only)"
-
-msgid "Custom Hooks"
-msgstr "Benutzerdefinierte Hooks"
-
 msgid ""
 "Hooks can be used to trigger actions on certain events such as push / "
 "pull. They can trigger Python functions or external applications."
@@ -2027,27 +1941,6 b' msgstr ""'
 msgid "Install Git hooks"
 msgstr "Git-Hooks installieren"
 
-msgid ""
-"Verify if Kallithea's Git hooks are installed for each repository. "
-"Current hooks will be updated to the latest version."
-msgstr ""
-"Überprüfen Sie, ob die Git-Hooks von Kallithea für jedes Repository "
-"installiert sind. Aktuelle Hooks werden auf die neueste Version "
-"aktualisiert."
-
-msgid "Overwrite existing Git hooks"
-msgstr "Bestehende Git-Hooks überschreiben"
-
-msgid ""
-"If installing Git hooks, overwrite any existing hooks, even if they do "
-"not seem to come from Kallithea. WARNING: This operation will destroy any "
-"custom git hooks you may have deployed by hand!"
-msgstr ""
-"Wenn Sie Git-Hooks installieren, überschreiben Sie alle vorhandenen "
-"Hooks, auch wenn sie nicht von Kallithea zu kommen scheinen. WARNUNG: "
-"Diese Operation zerstört alle benutzerdefinierten Git-Hooks, die Sie "
-"möglicherweise von Hand bereitgestellt haben!"
-
 msgid "Rescan Repositories"
 msgstr "Repositories erneut scannen"
 
@@ -2103,17 +1996,6 b' msgstr "Mercurial-Erweiterungen"'
 msgid "Enable largefiles extension"
 msgstr "Erweiterung largefiles aktivieren"
 
-msgid "Enable hgsubversion extension"
-msgstr "Erweiterung hgsubversion aktivieren"
-
-msgid ""
-"Requires hgsubversion library to be installed. Enables cloning of remote "
-"Subversion repositories while converting them to Mercurial."
-msgstr ""
-"Erfordert die Installation der hgsubversion-Bibliothek. Ermöglicht das "
-"Klonen von entfernten Subversion-Repositories während der Konvertierung "
-"zu Mercurial."
-
 msgid "Location of repositories"
 msgstr "Ort der Repositories"
 
@@ -2351,7 +2233,7 b' msgstr "Einen weiteren Kommentar hinzuf\xc3\xbcgen"'
 msgid "Group"
 msgstr "Gruppe"
 
-msgid "Confirm to revoke permission for {0}: {1} ?"
+msgid "Confirm to revoke permission for {0}: {1}?"
 msgstr "Widerruf der Rechte für {0}: {1} bestätigen?"
 
 msgid "Select changeset"
@@ -2441,6 +2323,9 b' msgstr "Abonniere den %s ATOM Feed"'
 msgid "Hello %s"
 msgstr "Hallo %s"
 
+msgid "Ignore whitespace"
+msgstr "Ignoriere unsichtbare Zeichen"
+
 msgid "or"
 msgstr "oder"
 

kallithea/i18n/el/LC_MESSAGES/kallithea.po

@@ -10,24 +10,30 b' msgstr ""'
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
 
+msgid ""
+"CSRF token leak has been detected - all form tokens have been expired"
+msgstr ""
+"Εντοπίστηκε διαρροή ενός διακριτικού CSRF - όλα τα διακριτικά της φόρμας "
+"έχουν λήξει"
+
+msgid "Repository not found in the filesystem"
+msgstr "Το αποθετήριο δε βρέθηκε στο σύστημα αρχείων"
+
 msgid "There are no changesets yet"
 msgstr "Δεν υπάρχουν σετ αλλαγών ακόμα"
 
+msgid "Changeset for %s %s not found in %s"
+msgstr "Το σετ αλλαγών για %s %sδεν βρέθηκε στο %s"
+
+msgid "SSH access is disabled."
+msgstr "Η πρόσβαση μέσω SSH είναι απενεργοποιημένη."
+
 msgid "None"
 msgstr "Χωρίς"
 
 msgid "(closed)"
 msgstr "(κλειστό)"
 
-msgid "Show whitespace"
-msgstr "Εμφάνιση κενού"
-
-msgid "Ignore whitespace"
-msgstr "Αγνόηση κενού"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Αύξηση του diff πλαισίου σε %(num)s γραμμές"
-
 msgid "No permission to change status"
 msgstr "Χωρίς δικαιώματα αλλαγής της κατάστασης"
 
@@ -543,13 +549,6 b' msgstr ""'
 msgid "Updated VCS settings"
 msgstr "Ενημερωμένες ρυθμίσεις VCS"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"Δεν γίνεται να ενεργοποιηθεί υποστήριξη για το hgsubversion. Λείπει η "
-"βιβλιοθήκη \"hgsubversion\""
-
 msgid "Error occurred while updating application settings"
 msgstr "Παρουσιάστηκε σφάλμα κατά την ενημέρωση των ρυθμίσεων της εφαρμογής"
 
@@ -578,11 +577,6 b' msgstr "\xce\x94\xce\xb7\xce\xbc\xce\xb9\xce\xbf\xcf\x85\xcf\x81\xce\xb3\xce\xae\xce\xb8\xce\xb7\xce\xba\xce\xb5 \xce\xb7 \xce\xb5\xcf\x81\xce\xb3\xce\xb1\xcf\x83\xce\xaf\xce\xb1 \xcf\x84\xce\xb7\xcf\x82 \xce\xb1\xcf\x80\xce\xbf\xcf\x83\xcf\x84\xce\xbf\xce\xbb\xce\xae\xcf\x82 \xce\xb7\xce\xbb\xce\xb5\xce\xba\xcf\x84\xcf\x81\xce\xbf\xce\xbd\xce\xb9\xce\xba\xce\xbf\xcf\x8d \xcf\x84\xce\xb1\xcf\x87\xcf\x85\xce\xb4\xcf\x81\xce\xbf\xce\xbc\xce\xb5\xce\xaf\xce\xbf\xcf\x85"'
 msgid "Hook already exists"
 msgstr "Το άγκιστρο υπάρχει ήδη"
 
-msgid "Builtin hooks are read-only. Please use another hook name."
-msgstr ""
-"Τα ενσωματωμένα άγκιστρα είναι μόνο για ανάγνωση. Παρακαλώ δώστε άλλο "
-"όνομα στο άγκιστρο."
-
 msgid "Added new hook"
 msgstr "Προσθήκη νέου άγκιστρου"
 
@@ -659,21 +653,6 b' msgstr ""'
 msgid "You need to be signed in to view this page"
 msgstr "Πρέπει να είστε συνδεμένος για να δείτε αυτήν τη σελίδα"
 
-msgid ""
-"CSRF token leak has been detected - all form tokens have been expired"
-msgstr ""
-"Εντοπίστηκε διαρροή ενός διακριτικού CSRF - όλα τα διακριτικά της φόρμας "
-"έχουν λήξει"
-
-msgid "Repository not found in the filesystem"
-msgstr "Το αποθετήριο δε βρέθηκε στο σύστημα αρχείων"
-
-msgid "Changeset for %s %s not found in %s"
-msgstr "Το σετ αλλαγών για %s %sδεν βρέθηκε στο %s"
-
-msgid "SSH access is disabled."
-msgstr "Η πρόσβαση μέσω SSH είναι απενεργοποιημένη."
-
 msgid "Binary file"
 msgstr "Δυαδικό αρχείο"
 
@@ -686,6 +665,9 b' msgstr ""'
 msgid "No changes detected"
 msgstr "Δεν εντοπίστηκαν αλλαγές"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Αύξηση του diff πλαισίου σε %(num)s γραμμές"
+
 msgid "Deleted branch: %s"
 msgstr "Διαγραφή κλάδου: %s"
 
@@ -797,40 +779,9 b' msgstr "\xce\xbc\xce\xb5\xcf\x84\xce\xbf\xce\xbd\xce\xbf\xce\xbc\xce\xb1\xcf\x83\xce\xaf\xce\xb1"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"Το αποθετήριο δεδομένων %s δεν έχει αντιστοιχιστεί στη βάση δεδομένων. "
-"Ίσως δημιουργήθηκε ή μετονομάστηκε από το σύστημα αρχείων. Εκτελέστε ξανά "
-"την εφαρμογή για να σαρώσετε ξανά τα αποθετήρια δεδομένων"
-
 msgid "SSH key is missing"
 msgstr "Το κλειδί SSH λείπει"
 
-msgid ""
-"Incorrect SSH key - it must have both a key type and a base64 part, like "
-"'ssh-rsa ASRNeaZu4FA...xlJp='"
-msgstr ""
-"Λανθασμένο κλειδί SSH - πρέπει να έχει έναν τύπο κλειδιού καθώς και ένα "
-"τμήμα base64, όπως \"ssh-rsa ASRNeaZu4FA ... xlJp =\""
-
-msgid "Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'"
-msgstr "Εσφαλμένο κλειδί SSH - πρέπει να ξεκινά με 'ssh-(rsa|dss|ed25519)'"
-
-msgid "Incorrect SSH key - unexpected characters in base64 part %r"
-msgstr ""
-"Εσφαλμένο κλειδί SSH - μη αναμενόμενοι χαρακτήρες στο τμήμα base64 %r"
-
-msgid "Incorrect SSH key - failed to decode base64 part %r"
-msgstr ""
-"Εσφαλμένο κλειδί SSH - απέτυχε η αποκωδικοποίηση του τμήματος base64 %r"
-
-msgid "Incorrect SSH key - base64 part is not %r as claimed but %r"
-msgstr ""
-"Εσφαλμένο κλειδί SSH - το base64 μέρος δεν είναι %r όπως ζητήθηκε, αλλά %r"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d έτος"
@@ -876,12 +827,6 b' msgstr "%s \xce\xba\xce\xb1\xce\xb9 %s \xcf\x80\xcf\x81\xce\xb9\xce\xbd"'
 msgid "just now"
 msgstr "μόλις τώρα"
 
-msgid "on line %s"
-msgstr "στη γραμμή %s"
-
-msgid "[Mention]"
-msgstr "[Αναφορά]"
-
 msgid "top level"
 msgstr "ανώτερο επίπεδο"
 
@@ -934,12 +879,6 b' msgid "Default user has admin access to '
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση διαχειριστή σε νέες ομάδες χρηστών"
 
-msgid "Only admins can create repository groups"
-msgstr "Μόνο οι διαχειριστές μπορούν να δημιουργήσουν ομάδες αποθετηρίων"
-
-msgid "Non-admins can create repository groups"
-msgstr "Οι μη διαχειριστές μπορούν να δημιουργήσουν ομάδες αποθετηρίων"
-
 msgid "Only admins can create user groups"
 msgstr "Μόνο οι διαχειριστές μπορούν να δημιουργήσουν ομάδες χρηστών"
 
@@ -954,18 +893,6 b' msgid "Non-admins can create top level r'
 msgstr ""
 "Οι μη διαχειριστές μπορούν να δημιουργήσουν αποθετήρια ανώτατου επιπέδου"
 
-msgid ""
-"Repository creation enabled with write permission to a repository group"
-msgstr ""
-"Η δημιουργία αποθετηρίου είναι ενεργοποιημένη με δικαιώματα εγγραφής σε "
-"μια ομάδα αποθετηρίων"
-
-msgid ""
-"Repository creation disabled with write permission to a repository group"
-msgstr ""
-"Η δημιουργία αποθετηρίου απενεργοποιήθηκε με δικαιώματα εγγραφής σε μια "
-"ομάδα αποθετηρίων"
-
 msgid "Only admins can fork repositories"
 msgstr "Μόνο οι διαχειριστές μπορούν να κλωνοποιήσουν τα αποθετήρια"
 
@@ -1014,12 +941,6 b' msgstr "\xce\x9a\xce\xb1\xcf\x84\xce\xb1\xcf\x87\xcf\x89\xcf\x81\xce\xae\xce\xb8\xce\xb7\xce\xba\xce\xb5 \xce\xbd\xce\xad\xce\xbf\xcf\x82 \xcf\x87\xcf\x81\xce\xae\xcf\x83\xcf\x84\xce\xb7\xcf\x82 %(new_username)s"'
 msgid "Closing"
 msgstr "Κλείσιμο"
 
-msgid ""
-"%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
-msgstr ""
-"Ο χρήστης %(user)s θέλει να αναθεωρήσετε την αίτηση έλξης %(pr_nice_id)s: "
-"%(pr_title)s"
-
 msgid "Cannot create empty pull request"
 msgstr "Δεν είναι δυνατή η δημιουργία κενής αίτησης έλξης"
 
@@ -1067,9 +988,6 b' msgstr "\xce\xa4\xce\xbf \xce\xba\xce\xbb\xce\xb5\xce\xb9\xce\xb4\xce\xaf SSH %s \xcf\x87\xcf\x81\xce\xb7\xcf\x83\xce\xb9\xce\xbc\xce\xbf\xcf\x80\xce\xbf\xce\xb9\xce\xb5\xce\xaf\xcf\x84\xce\xb1\xce\xb9 \xce\xae\xce\xb4\xce\xb7 \xce\xb1\xcf\x80\xcf\x8c \xcf\x84\xce\xbf \xcf\x87\xcf\x81\xce\xae\xcf\x83\xcf\x84\xce\xb7 %s"'
 msgid "SSH key with fingerprint %r found"
 msgstr "Βρέθηκε κλειδί SSH με δακτυλικό αποτύπωμα %r"
 
-msgid "New user registration"
-msgstr "Εγγραφή νέου χρήστη"
-
 msgid ""
 "You can't remove this user since it is crucial for the entire application"
 msgstr ""
@@ -1185,13 +1103,6 b' msgstr "\xce\x97 \xce\xbf\xce\xbc\xce\xac\xce\xb4\xce\xb1 \xce\xb1\xcf\x80\xce\xbf\xce\xb8\xce\xb5\xcf\x84\xce\xb7\xcf\x81\xce\xaf\xce\xbf\xcf\x85 \xce\xbc\xce\xb5 \xcf\x84\xce\xbf \xcf\x8c\xce\xbd\xce\xbf\xce\xbc\xce\xb1 \\"%(repo)s\\" \xcf\x85\xcf\x80\xce\xac\xcf\x81\xcf\x87\xce\xb5\xce\xb9 \xce\xae\xce\xb4\xce\xb7"'
 msgid "Invalid repository URL"
 msgstr "Μη έγκυρη διεύθυνση URL αποθετηρίου"
 
-msgid ""
-"Invalid repository URL. It must be a valid http, https, ssh, svn+http or "
-"svn+https URL"
-msgstr ""
-"Μη έγκυρη διεύθυνση URL του αποθετηρίου. Πρέπει να είναι μια έγκυρη http, "
-"https, ssh, svn+http ή svn+https διεύθυνση URL"
-
 msgid "Fork has to be the same type as parent"
 msgstr "Ο κλώνος πρέπει να έχει τον ίδιο τύπο με τον γονέα του"
 
@@ -1293,10 +1204,10 b' msgid "Stay logged in after browser rest'
 msgstr ""
 "Μείνετε συνδεδεμένοι μετά την επανεκκίνηση του προγράμματος περιήγησης"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "Ξεχάσατε τον κωδικό σας;"
 
-msgid "Don't have an account ?"
+msgid "Don't have an account?"
 msgstr "Δεν έχετε λογαριασμό;"
 
 msgid "Sign In"
@@ -1788,26 +1699,6 b' msgstr ""'
 "Ενεργοποιήστε αυτήν την επιλογή ώστε να επιτρέπεται σε μη διαχειριστές να "
 "δημιουργούν αποθετήρια στο ανώτερο επίπεδο."
 
-msgid ""
-"Note: This will also give all users API access to create repositories "
-"everywhere. That might change in future versions."
-msgstr ""
-"Σημείωση: Αυτό θα δώσει επίσης σε όλους τους χρήστες πρόσβαση API για τη "
-"δημιουργία αποθετηρίων παντού. Αυτό μπορεί να αλλάξει σε μελλοντικές "
-"εκδόσεις."
-
-msgid "Repository creation with group write access"
-msgstr "Δημιουργία αποθετηρίου με πρόσβαση εγγραφής ομάδας"
-
-msgid ""
-"With this, write permission to a repository group allows creating "
-"repositories inside that group. Without this, group write permissions "
-"mean nothing."
-msgstr ""
-"Με αυτό, η άδεια εγγραφής σε μια ομάδα αποθετηρίων επιτρέπει τη "
-"δημιουργία αποθετηρίων εντός αυτής της ομάδας. Χωρίς αυτό, τα δικαιώματα "
-"ομαδικής εγγραφής δεν σημαίνουν τίποτα."
-
 msgid "User group creation"
 msgstr "Δημιουργία ομάδας χρηστών"
 
@@ -2245,12 +2136,6 b' msgstr ""'
 msgid "Save Settings"
 msgstr "Αποθήκευση Ρυθμίσεων"
 
-msgid "Built-in Mercurial Hooks (Read-Only)"
-msgstr "Ενσωματωμένοι Mercurial Hooks (μόνο για ανάγνωση)"
-
-msgid "Custom Hooks"
-msgstr "Προσαρμοσμένα άγκιστρα"
-
 msgid "Failed to remove hook"
 msgstr "Απέτυχε η αφαίρεση γάντζου"
 
@@ -2279,26 +2164,6 b' msgstr ""'
 msgid "Install Git hooks"
 msgstr "Εγκατάσταση Git hooks"
 
-msgid ""
-"Verify if Kallithea's Git hooks are installed for each repository. "
-"Current hooks will be updated to the latest version."
-msgstr ""
-"Επαληθεύστε εάν τα Git hooks της Καλλιθέας είναι εγκατεστημένα για κάθε "
-"αποθετήριο. Τα τρέχοντα hooks θα ενημερωθούν στην τελευταία έκδοση."
-
-msgid "Overwrite existing Git hooks"
-msgstr "Αντικατάσταση υπαρχόντων Git hooks"
-
-msgid ""
-"If installing Git hooks, overwrite any existing hooks, even if they do "
-"not seem to come from Kallithea. WARNING: This operation will destroy any "
-"custom git hooks you may have deployed by hand!"
-msgstr ""
-"Εάν εγκαθιστάτε Git hooks, αντικαταστήστε τυχόν υπάρχοντα hooks, ακόμα κι "
-"αν δεν φαίνεται να προέρχονται από την Καλλιθέα. ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Αυτή η "
-"λειτουργία θα καταστρέψει τυχόν προσαρμοσμένα git hooks που μπορεί να "
-"έχετε αναπτύξει με το χέρι!"
-
 msgid "Rescan Repositories"
 msgstr "Επανασάρωση αποθετηρίων"
 
@@ -2354,17 +2219,6 b' msgstr "\xce\x95\xcf\x80\xce\xb5\xce\xba\xcf\x84\xce\xac\xcf\x83\xce\xb5\xce\xb9\xcf\x82 Mercurial"'
 msgid "Enable largefiles extension"
 msgstr "Ενεργοποίηση επέκτασης μεγάλων αρχείων"
 
-msgid "Enable hgsubversion extension"
-msgstr "Ενεργοποίηση επέκτασης hgsubversion"
-
-msgid ""
-"Requires hgsubversion library to be installed. Enables cloning of remote "
-"Subversion repositories while converting them to Mercurial."
-msgstr ""
-"Απαιτεί την εγκατάσταση της βιβλιοθήκης hgsubversion. Ενεργοποιεί την "
-"κλωνοποίηση απομακρυσμένων Subversion αποθετηρίων και τη μετατροπή τους "
-"σε Mercurial."
-
 msgid "Location of repositories"
 msgstr "Τοποθεσία αποθετηρίων"
 
@@ -2727,9 +2581,6 b' msgstr "\xce\xa3\xcf\x85\xce\xbd\xce\xb4\xce\xb5\xce\xb8\xce\xb5\xce\xaf\xcf\x84\xce\xb5 \xcf\x83\xcf\x84\xce\xbf \xce\xbb\xce\xbf\xce\xb3\xce\xb1\xcf\x81\xce\xb9\xce\xb1\xcf\x83\xce\xbc\xcf\x8c \xcf\x83\xce\xb1\xcf\x82"'
 msgid "Forgot password?"
 msgstr "Ξεχάσατε τον κωδικό πρόσβασης;"
 
-msgid "Don't have an account?"
-msgstr "Δεν έχετε λογαριασμό;"
-
 msgid "Log Out"
 msgstr "Αποσύνδεση"
 
@@ -2840,7 +2691,7 b' msgstr ""'
 msgid "Failed to revoke permission"
 msgstr "Απέτυχε η ανάκληση του δικαιωμάτος"
 
-msgid "Confirm to revoke permission for {0}: {1} ?"
+msgid "Confirm to revoke permission for {0}: {1}?"
 msgstr "Επιβεβαιώστε την ανάκληση του δικαιώματος για {0}: {1};"
 
 msgid "Select changeset"
@@ -3260,6 +3111,9 b' msgstr "%s \xce\x91\xcf\x81\xcf\x87\xce\xb5\xce\xaf\xce\xbf \xce\xb4\xce\xb9\xce\xb1\xcf\x86\xce\xbf\xcf\x81\xce\xac\xcf\x82 \xce\xb4\xce\xaf\xcf\x80\xce\xbb\xce\xb1-\xce\xb4\xce\xaf\xcf\x80\xce\xbb\xce\xb1"'
 msgid "File diff"
 msgstr "Αρχείο διαφοράς"
 
+msgid "Ignore whitespace"
+msgstr "Αγνόηση κενού"
+
 msgid "%s File Diff"
 msgstr "%s Αρχείο διαφοράς"
 

kallithea/i18n/es/LC_MESSAGES/kallithea.po

@@ -19,15 +19,6 b' msgstr "Ninguno"'
 msgid "(closed)"
 msgstr "(cerrado)"
 
-msgid "Show whitespace"
-msgstr "Mostrar espacios en blanco"
-
-msgid "Ignore whitespace"
-msgstr "Ignorar espacios en blanco"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Aumentar el contexto del diff a %(num)s lineas"
-
 msgid "Successfully deleted pull request %s"
 msgstr "Petición de pull %s eliminada correctamente"
 
@@ -280,5 +271,11 b' msgstr "Sin modificar"'
 msgid "Successfully updated gist content"
 msgstr "Gist actualizado correctamente"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Aumentar el contexto del diff a %(num)s lineas"
+
 msgid "Select changeset"
 msgstr "Seleccionar cambios"
+
+msgid "Ignore whitespace"
+msgstr "Ignorar espacios en blanco"

kallithea/i18n/fr/LC_MESSAGES/kallithea.po

@@ -10,24 +10,30 b' msgstr ""'
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n > 1;\n"
 
+msgid ""
+"CSRF token leak has been detected - all form tokens have been expired"
+msgstr ""
+"Une fuite de jeton CSRF a été détectée - tous les jetons de formulaire "
+"sont considérés comme expirés"
+
+msgid "Repository not found in the filesystem"
+msgstr "Dépôt non trouvé sur le système de fichiers"
+
 msgid "There are no changesets yet"
 msgstr "Il n’y a aucun changement pour le moment"
 
+msgid "Changeset for %s %s not found in %s"
+msgstr "Ensemble de changements pour %s %s non trouvé dans %s"
+
+msgid "SSH access is disabled."
+msgstr "L'accès SSH est désactivé."
+
 msgid "None"
 msgstr "Aucun"
 
 msgid "(closed)"
 msgstr "(fermé)"
 
-msgid "Show whitespace"
-msgstr "Afficher les espaces et tabulations"
-
-msgid "Ignore whitespace"
-msgstr "Ignorer les espaces et tabulations"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Augmenter le contexte du diff à %(num)s lignes"
-
 msgid "No permission to change status"
 msgstr "Permission manquante pour changer le statut"
 
@@ -549,13 +555,6 b' msgstr ""'
 msgid "Updated VCS settings"
 msgstr "Réglages des gestionnaires de versions mis à jour"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"Impossible d'activer la prise en charge de hgsubversion. La bibliothèque "
-"« hgsubversion » est manquante"
-
 msgid "Error occurred while updating application settings"
 msgstr ""
 "Une erreur est survenue durant la mise à jour des réglages de "
@@ -587,10 +586,12 b' msgstr "T\xc3\xa2che d\'envoi d\'e-mail cr\xc3\xa9\xc3\xa9e"'
 msgid "Hook already exists"
 msgstr "Le hook existe déjà"
 
-msgid "Builtin hooks are read-only. Please use another hook name."
+msgid ""
+"Hook names with \".kallithea_\" are reserved for internal use. Please use "
+"another hook name."
 msgstr ""
-"Les hooks intégrés sont en lecture seule. Merci de choisir un autre nom "
-"pour le hook."
+"Les noms de hook avec \".kallithea_\" sont réservés pour un usage interne. "
+"Merci de choisir un autre nom pour le hook."
 
 msgid "Added new hook"
 msgstr "Le nouveau hook a été ajouté"
@@ -671,21 +672,6 b' msgstr ""'
 msgid "You need to be signed in to view this page"
 msgstr "Vous devez être connecté pour visualiser cette page"
 
-msgid ""
-"CSRF token leak has been detected - all form tokens have been expired"
-msgstr ""
-"Une fuite de jeton CSRF a été détectée - tous les jetons de formulaire "
-"sont considérés comme expirés"
-
-msgid "Repository not found in the filesystem"
-msgstr "Dépôt non trouvé sur le système de fichiers"
-
-msgid "Changeset for %s %s not found in %s"
-msgstr "Ensemble de changements pour %s %s non trouvé dans %s"
-
-msgid "SSH access is disabled."
-msgstr "L'accès SSH est désactivé."
-
 msgid "Binary file"
 msgstr "Fichier binaire"
 
@@ -698,6 +684,15 b' msgstr ""'
 msgid "No changes detected"
 msgstr "Aucun changement détecté"
 
+msgid "Show whitespace changes"
+msgstr "Afficher les modifications d'espaces et de tabulations"
+
+msgid "Ignore whitespace changes"
+msgstr "Ignorer les modifications d'espaces et de tabulations"
+
+msgid "Increase diff context to %(num)s lines"
+msgstr "Augmenter le contexte du diff à %(num)s lignes"
+
 msgid "Deleted branch: %s"
 msgstr "Branche supprimée : %s"
 
@@ -809,40 +804,55 b' msgstr "renommer"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"Le dépôt %s n’est pas représenté dans la base de données. Il a "
-"probablement été créé ou renommé manuellement. Veuillez relancer "
-"l’application pour rescanner les dépôts"
-
 msgid "SSH key is missing"
 msgstr "La clé SSH est manquante"
 
 msgid ""
-"Incorrect SSH key - it must have both a key type and a base64 part, like "
+"Invalid SSH key - it must have both a key type and a base64 part, like "
 "'ssh-rsa ASRNeaZu4FA...xlJp='"
 msgstr ""
-"Clé SSH incorrecte – elle doit comporter à la fois un type de clé et une "
+"Clé SSH invalide – elle doit comporter à la fois un type de clé et une "
 "partie base64, comme 'ssh-rsa ASRNeaZu4FA...xlJp='"
 
-msgid "Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'"
+msgid ""
+"Invalid SSH key - it must start with key type 'ssh-rsa', 'ssh-dss', 'ssh-"
+"ed448', or 'ssh-ed25519'"
 msgstr ""
-"Clé SSH incorrecte – elle doit commencer par « ssh-(rsa|dss|ed25519) »"
-
-msgid "Incorrect SSH key - unexpected characters in base64 part %r"
+"Clé SSH invalide – elle doit commencer par le type de clé 'ssh-rsa', 'ssh-"
+"dss', 'ssh-ed448', ou 'ssh-ed25519'"
+
+msgid "Invalid SSH key - unexpected characters in base64 part %r"
+msgstr "Clé SSH invalide – caractères inattendus dans la partie base 64 %r"
+
+msgid ""
+"Invalid SSH key - base64 part %r seems truncated (it can't be decoded)"
 msgstr ""
-"Clé SSH incorrecte – caractères inattendus dans la partie base 64 %r"
-
-msgid "Incorrect SSH key - failed to decode base64 part %r"
-msgstr "Clé SSH incorrecte – échec du décodage de la partie base64 %r"
-
-msgid "Incorrect SSH key - base64 part is not %r as claimed but %r"
+"Clé SSH invalide – la partie base64 %r semble tronquée (elle ne peut pas "
+"être décodée)"
+
+msgid ""
+"Invalid SSH key - base64 part %r seems truncated (it contains a partial "
+"string length)"
 msgstr ""
-"Clé SSH incorrecte – la partie base 64 n'est pas %r comme il est dit mais "
-"%r"
+"Clé SSH invalide – la partie base64 %r semble tronquée (elle contient une "
+"taille partielle)"
+
+msgid ""
+"Invalid SSH key - base64 part %r seems truncated (it is too short for "
+"declared string length %s)"
+msgstr ""
+"Clé SSH invalide – la partie base64 %r semble tronquée (elle est trop court "
+"pour la taille déclarée %s)"
+
+msgid ""
+"Invalid SSH key - base64 part %r seems truncated (it contains too few "
+"strings for a %s key)"
+msgstr ""
+"Clé SSH invalide – la partie base64 %r semble tronquée (elle ne contient pas "
+"assez de parties pour une clé %s)"
+
+msgid "Invalid SSH key - it is a %s key but the base64 part contains %r"
+msgstr "Clé SSH invalide – c'est une clé %s mais la partie base64 contient %r"
 
 msgid "%d year"
 msgid_plural "%d years"
@@ -889,12 +899,6 b' msgstr "Il y a %s et %s"'
 msgid "just now"
 msgstr "à l’instant"
 
-msgid "on line %s"
-msgstr "à la ligne %s"
-
-msgid "[Mention]"
-msgstr "[Mention]"
-
 msgid "top level"
 msgstr "niveau supérieur"
 
@@ -952,13 +956,6 b' msgstr ""'
 "L'utilisateur par défaut a un accès administrateur aux nouveaux groupes "
 "d'utilisateurs"
 
-msgid "Only admins can create repository groups"
-msgstr "Seul un administrateur peut créer un groupe de dépôts"
-
-msgid "Non-admins can create repository groups"
-msgstr ""
-"Les utilisateurs non-administrateurs peuvent créer des groupes de dépôts"
-
 msgid "Only admins can create user groups"
 msgstr "Seul un administrateur peut créer des groupes d'utilisateurs"
 
@@ -975,18 +972,6 b' msgstr ""'
 "Les utilisateurs non-administrateurs peuvent créer des dépôts de niveau "
 "supérieur"
 
-msgid ""
-"Repository creation enabled with write permission to a repository group"
-msgstr ""
-"Création de dépôts activée avec l'accès en écriture vers un groupe de "
-"dépôts"
-
-msgid ""
-"Repository creation disabled with write permission to a repository group"
-msgstr ""
-"Création de dépôts désactivée avec l'accès en écriture vers un groupe de "
-"dépôts"
-
 msgid "Only admins can fork repositories"
 msgstr "Seul un administrateur peut faire un fork de dépôt"
 
@@ -1032,10 +1017,10 b' msgstr "Le nom ne doit pas contenir seul'
 
 msgid ""
 "[Comment] %(repo_name)s changeset %(short_id)s \"%(message_short)s\" on "
-"%(branch)s"
+"%(branch)s by %(cs_author_username)s"
 msgstr ""
-"[Commentaire] Changeset %(short_id)s « %(message_short)s » de "
-"%(repo_name)s dans %(branch)s"
+"[Commentaire] Changeset %(short_id)s « %(message_short)s » de %(repo_name)s "
+"dans %(branch)s par %(cs_author_username)s"
 
 msgid "New user %(new_username)s registered"
 msgstr "Nouvel utilisateur %(new_username)s enregistré"
@@ -1057,12 +1042,6 b' msgstr ""'
 msgid "Closing"
 msgstr "Fermeture"
 
-msgid ""
-"%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
-msgstr ""
-"%(user)s veut que vous regardiez la demande de pull %(pr_nice_id)s : "
-"%(pr_title)s"
-
 msgid "Cannot create empty pull request"
 msgstr "Impossible de créer une requête de pull vide"
 
@@ -1110,9 +1089,6 b' msgstr "La cl\xc3\xa9 SSH %s est d\xc3\xa9j\xc3\xa0 utilis\xc3\xa9e par %s"'
 msgid "SSH key with fingerprint %r found"
 msgstr "Clé SSH avec l'empreinte %r trouvée"
 
-msgid "New user registration"
-msgstr "Nouveau enregistrement d'utilisateur"
-
 msgid ""
 "You can't remove this user since it is crucial for the entire application"
 msgstr ""
@@ -1227,12 +1203,9 b' msgstr "Un groupe de d\xc3\xa9p\xc3\xb4ts avec le nom \xc2\xab\xe2\x80\xaf%(repo)s\xe2\x80\xaf\xc2\xbb existe d\xc3\xa9j\xc3\xa0"'
 msgid "Invalid repository URL"
 msgstr "URL de dépôt invalide"
 
-msgid ""
-"Invalid repository URL. It must be a valid http, https, ssh, svn+http or "
-"svn+https URL"
+msgid "Invalid repository URL. It must be a valid http, https, or ssh URL"
 msgstr ""
-"URL de dépôt invalide. Ce doit être une URL valide de type http, https, "
-"ssh, svn+http ou svn+https"
+"URL de dépôt invalide. Ce doit être une URL valide de type http, https ou ssh"
 
 msgid "Fork has to be the same type as parent"
 msgstr "Le fork doit être du même type que le parent"
@@ -1334,10 +1307,10 b' msgstr "Mot de passe"'
 msgid "Stay logged in after browser restart"
 msgstr "Rester connecté après un redémarrage du navigateur"
 
-msgid "Forgot your password ?"
-msgstr "Mot de passe oublié ?"
-
-msgid "Don't have an account ?"
+msgid "Forgot your password?"
+msgstr "Mot de passe oublié?"
+
+msgid "Don't have an account?"
 msgstr "Vous n’avez pas de compte ?"
 
 msgid "Sign In"
@@ -1826,26 +1799,6 b' msgstr ""'
 "Activer pour autoriser les non-administrateurs à créer des dépôts au "
 "niveau supérieur."
 
-msgid ""
-"Note: This will also give all users API access to create repositories "
-"everywhere. That might change in future versions."
-msgstr ""
-"Note : Cela autorisera également tous les utilisateurs à utiliser l'API "
-"pour créer des dépôts partout. Ce comportement peut changer dans des "
-"versions futures."
-
-msgid "Repository creation with group write access"
-msgstr "Création de dépôts avec l'accès en écriture du groupe"
-
-msgid ""
-"With this, write permission to a repository group allows creating "
-"repositories inside that group. Without this, group write permissions "
-"mean nothing."
-msgstr ""
-"Avec ceci, le droit d'écriture dans un groupe de dépôt donne le droit de "
-"créer des dépôts dans ce groupe. Sans ceci, le droit d'écriture pour les "
-"groupes n'a pas d'impact."
-
 msgid "User group creation"
 msgstr "Création de groupes d'utilisateurs"
 
@@ -2276,11 +2229,8 b' msgstr ""'
 msgid "Save Settings"
 msgstr "Enregistrer les options"
 
-msgid "Built-in Mercurial Hooks (Read-Only)"
-msgstr "Hooks Mercurial intégrés (lecture seule)"
-
-msgid "Custom Hooks"
-msgstr "Hooks personnalisés"
+msgid "Custom Global Mercurial Hooks"
+msgstr "Hooks Mercurial globaux personnalisés"
 
 msgid ""
 "Hooks can be used to trigger actions on certain events such as push / "
@@ -2290,6 +2240,21 b' msgstr ""'
 "certains évènements comme le push et le pull. Ils peuvent déclencher des "
 "fonctions Python ou des applications externes."
 
+msgid "Git Hooks"
+msgstr "Git Hooks"
+
+msgid ""
+"Kallithea has no support for custom Git hooks. Kallithea will use Git "
+"post-receive hooks internally. Installation of these hooks is managed in "
+"%s."
+msgstr ""
+"Kallithea ne supporte pas les hooks Git personnalisés. Kallithea utilise des "
+"hooks Git de post-réception en interne. L'installation de ces hooks est "
+"gérée dans %s."
+
+msgid "Custom Hooks are not enabled"
+msgstr "Les Hooks personnalisés ne sont pas activés"
+
 msgid "Failed to remove hook"
 msgstr "Erreur lors de la suppression du hook"
 
@@ -2318,23 +2283,25 b' msgid "Install Git hooks"'
 msgstr "Installer des hooks Git"
 
 msgid ""
-"Verify if Kallithea's Git hooks are installed for each repository. "
-"Current hooks will be updated to the latest version."
+"Install Kallithea's internal hooks for all Git repositories where they "
+"are missing or can be upgraded. Existing hooks that don't seem to come "
+"from Kallithea will not be touched."
 msgstr ""
-"Vérifier si les hooks Git de Kallithea sont installés pour chaque dépôt. "
-"Les hooks actuels seront mis à jour vers la dernière version."
-
-msgid "Overwrite existing Git hooks"
-msgstr "Écraser les hooks Git existants"
+"Installe les hooks internes de Kallithea pour tous les dépôts Git où ils "
+"sont absents ou s'ils peuvent être mis à jour. Les hooks existants qui ne "
+"semblent pas être livrés avec Kallithea ne seront pas impactés."
+
+msgid "Install and overwrite Git hooks"
+msgstr "Installer et surcharger des hooks Git"
 
 msgid ""
-"If installing Git hooks, overwrite any existing hooks, even if they do "
-"not seem to come from Kallithea. WARNING: This operation will destroy any "
-"custom git hooks you may have deployed by hand!"
+"Install Kallithea's internal hooks for all Git repositories. Existing "
+"hooks that don't seem to come from Kallithea will be disabled by renaming "
+"to .bak extension."
 msgstr ""
-"Lors de l'installation des hooks Git, écraser tous les hooks existants, "
-"même s'ils ne semblent pas provenir de Kallithea. ATTENTION : cette "
-"opération détruira tous les hooks Git que vous avez déployés à la main !"
+"Installe les hooks internes de Kallithea pour tous les dépôts Git. Les hooks "
+"existants qui ne semblent pas être livrés avec Kallithea seront désactivés "
+"en les renommant avec l'extension .bak."
 
 msgid "Rescan Repositories"
 msgstr "Relancer le scan des dépôts"
@@ -2379,6 +2346,9 b' msgstr "Chemin de Git"'
 msgid "Python Packages"
 msgstr "Paquets Python"
 
+msgid "Mercurial Push Hooks"
+msgstr "Hooks Push Mercurial"
+
 msgid "Show repository size after push"
 msgstr "Afficher la taille du dépôt après un push"
 
@@ -2391,16 +2361,6 b' msgstr "Extensions Mercurial"'
 msgid "Enable largefiles extension"
 msgstr "Activer l'extension largefiles"
 
-msgid "Enable hgsubversion extension"
-msgstr "Activer l'extension hgsubversion"
-
-msgid ""
-"Requires hgsubversion library to be installed. Enables cloning of remote "
-"Subversion repositories while converting them to Mercurial."
-msgstr ""
-"La bibliothèque hgsubversion doit être installée. Elle permet de cloner "
-"des dépôts SVN distants et de les migrer vers Mercurial."
-
 msgid "Location of repositories"
 msgstr "Emplacement des dépôts"
 
@@ -2472,6 +2432,47 b' msgstr ""'
 "emplacement réseau/hôte du serveur Kallithea en cours d'utilisation."
 
 msgid ""
+"Schema of clone URL construction eg. '{scheme}://{user}@{netloc}/"
+"{repo}'.\n"
+"                                                    The following "
+"variables are available:\n"
+"                                                    {scheme} 'http' or "
+"'https' sent from running Kallithea server,\n"
+"                                                    {user}   current user "
+"username,\n"
+"                                                    {netloc} network "
+"location/server host of running Kallithea server,\n"
+"                                                    {repo}   full "
+"repository name,\n"
+"                                                    {repoid} ID of "
+"repository, can be used to construct clone-by-id,\n"
+"                                                    {system_user}  name "
+"of the Kallithea system user,\n"
+"                                                    {hostname}  server "
+"hostname\n"
+"                                                    "
+msgstr ""
+"Modèle de construction d'URL de clone. Par exemple : "
+"'{scheme}://{user}@{netloc}/{repo}'.\n"
+"                                                       Les variables "
+"suivantes sont disponibles :\n"
+"                                                        {scheme}    'http' "
+"ou 'https' envoyé à partir du serveur Kallithea en cours d'utilisation,\n"
+"                                                        {user}     nom de "
+"l'utilisateur courant,\n"
+"                                                        {netloc}    "
+"emplacement réseau/hôte du serveur Kallithea en cours d'utilisation,\n"
+"                                                        {repo}    nom "
+"complet du dépôt,\n"
+"                                                        {repoid}    ID du "
+"dépôt, peut être utilisé pour cloner par ID,\n"
+"                                                        {system_user}  nom "
+"de l'utilisateur système Kallithea,\n"
+"                                                        {hostname}  nom "
+"d'hôte du serveur\n"
+"                                                    "
+
+msgid ""
 "Schema for constructing SSH clone URL, eg. 'ssh://{system_user}"
 "@{hostname}/{repo}'."
 msgstr ""
@@ -2715,9 +2716,6 b' msgstr "Connexion \xc3\xa0 votre compte"'
 msgid "Forgot password?"
 msgstr "Mot de passe oublié ?"
 
-msgid "Don't have an account?"
-msgstr "Vous n’avez pas de compte ?"
-
 msgid "Log Out"
 msgstr "Se déconnecter"
 
@@ -2827,7 +2825,7 b' msgstr ""'
 msgid "Failed to revoke permission"
 msgstr "Échec de la révocation de permission"
 
-msgid "Confirm to revoke permission for {0}: {1} ?"
+msgid "Confirm to revoke permission for {0}: {1}?"
 msgstr "Voulez-vous vraiment révoquer la permission pour {0} : {1} ?"
 
 msgid "Select changeset"
@@ -2908,6 +2906,9 b' msgstr ""'
 msgid "Changeset status: %s by %s"
 msgstr "Statut de changeset : %s par %s"
 
+msgid "(No commit message)"
+msgstr "(Pas de message de commit)"
+
 msgid "Expand commit message"
 msgstr "Développer le message de commit"
 
@@ -3070,6 +3071,12 b' msgstr "Afficher le diff complet pour ce'
 msgid "Show full side-by-side diff for this file"
 msgstr "Afficher le diff complet côte-à-côte pour ce fichier"
 
+msgid "Raw diff for this file"
+msgstr "Diff brut pour ce fichier"
+
+msgid "Download diff for this file"
+msgstr "Télécharger le diff pour ce fichier"
+
 msgid "Show inline comments"
 msgstr "Afficher les commentaires de ligne"
 
@@ -3243,6 +3250,9 b' msgstr "Diff c\xc3\xb4te-\xc3\xa0-c\xc3\xb4te de fichier pour %s"'
 msgid "File diff"
 msgstr "Diff de fichier"
 
+msgid "Ignore whitespace"
+msgstr "Ignorer les espaces et tabulations"
+
 msgid "%s File Diff"
 msgstr "Diff de fichier pour %s"
 

kallithea/i18n/ja/LC_MESSAGES/kallithea.po

@@ -10,6 +10,9 b' msgstr ""'
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=1; plural=0;\n"
 
+msgid "Repository not found in the filesystem"
+msgstr "ファイルシステム内にリポジトリが見つかりません"
+
 msgid "There are no changesets yet"
 msgstr "まだチェンジセットがありません"
 
@@ -19,15 +22,6 b' msgstr "\xe3\x81\xaa\xe3\x81\x97"'
 msgid "(closed)"
 msgstr "(閉鎖済み)"
 
-msgid "Show whitespace"
-msgstr "空白を表示"
-
-msgid "Ignore whitespace"
-msgstr "空白を無視"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "diff コンテキストを %(num)s 行増やす"
-
 msgid "Such revision does not exist for this repository"
 msgstr "お探しのリビジョンはこのリポジトリにはありません"
 
@@ -435,13 +429,6 b' msgstr "\xe3\x83\xaa\xe3\x83\x9d\xe3\x82\xb8\xe3\x83\x88\xe3\x83\xaa\xe3\x82\xb9\xe3\x83\x86\xe3\x83\xbc\xe3\x83\x88\xe3\x81\xae\xe5\x89\x8a\xe9\x99\xa4\xe4\xb8\xad\xe3\x81\xab\xe3\x82\xa8\xe3\x83\xa9\xe3\x83\xbc\xe3\x81\x8c\xe7\x99\xba\xe7\x94\x9f\xe3\x81\x97\xe3\x81\xbe\xe3\x81\x97\xe3\x81\x9f"'
 msgid "Updated VCS settings"
 msgstr "VCS設定を更新しました"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"\"hgsubversion\"ライブラリが見つからないため、hgsubversionサポートを有効に"
-"出来ません"
-
 msgid "Error occurred while updating application settings"
 msgstr "アプリケーション設定の更新中にエラーが発生しました"
 
@@ -539,9 +526,6 b' msgstr ""'
 msgid "You need to be signed in to view this page"
 msgstr "このページを閲覧するためにはサインインが必要です"
 
-msgid "Repository not found in the filesystem"
-msgstr "ファイルシステム内にリポジトリが見つかりません"
-
 msgid "Binary file"
 msgstr "バイナリファイル"
 
@@ -554,6 +538,9 b' msgstr ""'
 msgid "No changes detected"
 msgstr "検出された変更はありません"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "diff コンテキストを %(num)s 行増やす"
+
 msgid "Deleted branch: %s"
 msgstr "削除されたブランチ: %s"
 
@@ -662,15 +649,6 b' msgstr "\xe3\x83\xaa\xe3\x83\x8d\xe3\x83\xbc\xe3\x83\xa0"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"%s リポジトリはDB内に見つかりませんでした。おそらくファイルシステム上で作"
-"られたか名前が変更されたためです。リポジトリをもう一度チェックするためにア"
-"プリケーションを再起動してください"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d 年"
@@ -710,12 +688,6 b' msgstr "%s \xe3\x81\xa8 %s \xe5\x89\x8d"'
 msgid "just now"
 msgstr "たったいま"
 
-msgid "on line %s"
-msgstr "%s 行目"
-
-msgid "[Mention]"
-msgstr "[Mention]"
-
 msgid "top level"
 msgstr "top level"
 
@@ -733,12 +705,6 b' msgid "Default user has write access to '
 msgstr ""
 "デフォルトユーザーは新しいリポジトリに書き込みアクセスする権限があります"
 
-msgid "Only admins can create repository groups"
-msgstr "管理者のみがリポジトリのグループを作成できます"
-
-msgid "Non-admins can create repository groups"
-msgstr "非管理者がリポジトリのグループを作成できます"
-
 msgid "Only admins can create user groups"
 msgstr "管理者だけがユーザー グループを作成することができます"
 
@@ -751,16 +717,6 b' msgstr "\xe7\xae\xa1\xe7\x90\x86\xe8\x80\x85\xe3\x81\xa0\xe3\x81\x91\xe3\x81\x8c\xe3\x83\x88\xe3\x83\x83\xe3\x83\x97\xe3\x83\xac\xe3\x83\x99\xe3\x83\xab\xe3\x81\xab\xe3\x83\xaa\xe3\x83\x9d\xe3\x82\xb8\xe3\x83\x88\xe3\x83\xaa\xe3\x82\x92\xe4\xbd\x9c\xe6\x88\x90\xe3\x81\x99\xe3\x82\x8b\xe3\x81\x93\xe3\x81\xa8\xe3\x81\x8c\xe3\x81\xa7\xe3\x81\x8d\xe3\x81\xbe\xe3\x81\x99"'
 msgid "Non-admins can create top level repositories"
 msgstr "非管理者がトップレベルにリポジトリを作成することができます"
 
-msgid ""
-"Repository creation enabled with write permission to a repository group"
-msgstr ""
-"リポジトリグループの書き込みパーミッションを使ったリポジトリ作成が有効です"
-
-msgid ""
-"Repository creation disabled with write permission to a repository group"
-msgstr ""
-"リポジトリグループの書き込みパーミッションを使ったリポジトリ作成は無効です"
-
 msgid "Only admins can fork repositories"
 msgstr "管理者のみがリポジトリをフォークすることができます"
 
@@ -803,18 +759,9 b' msgstr "\xe6\x96\xb0\xe3\x81\x97\xe3\x81\x84\xe3\x83\xa6\xe3\x83\xbc\xe3\x82\xb6\xe3\x83\xbc %(new_username)s \xe3\x81\x8c\xe7\x99\xbb\xe9\x8c\xb2\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xbe\xe3\x81\x97\xe3\x81\x9f"'
 msgid "Closing"
 msgstr "クローズ"
 
-msgid ""
-"%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
-msgstr ""
-"%(user)s がプリリクエスト #%(pr_nice_id)s: %(pr_title)s のレビューを求めて"
-"います"
-
 msgid "latest tip"
 msgstr "最新のtip"
 
-msgid "New user registration"
-msgstr "新規ユーザー登録"
-
 msgid ""
 "User \"%s\" still owns %s repositories and cannot be removed. Switch "
 "owners or remove those repositories: %s"
@@ -1007,10 +954,10 b' msgstr "\xe3\x83\xa6\xe3\x83\xbc\xe3\x82\xb6\xe3\x83\xbc\xe5\x90\x8d"'
 msgid "Password"
 msgstr "パスワード"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "パスワードを忘れた?"
 
-msgid "Don't have an account ?"
+msgid "Don't have an account?"
 msgstr "アカウントを持っていない?"
 
 msgid "Sign In"
@@ -1357,9 +1304,6 b' msgstr "\xe3\x83\xa6\xe3\x83\xbc\xe3\x82\xb6\xe3\x83\xbc\xe3\x82\xb0\xe3\x83\xab\xe3\x83\xbc\xe3\x83\x97"'
 msgid "Top level repository creation"
 msgstr "トップレベルリポジトリの作成"
 
-msgid "Repository creation with group write access"
-msgstr "グループ書き込み権限でのリポジトリ作成"
-
 msgid "User group creation"
 msgstr "ユーザーグループ作成"
 
@@ -1711,12 +1655,6 b' msgstr ""'
 msgid "Save Settings"
 msgstr "設定を保存"
 
-msgid "Built-in Mercurial Hooks (Read-Only)"
-msgstr "組み込みのMercurialフック (編集不可)"
-
-msgid "Custom Hooks"
-msgstr "カスタムフック"
-
 msgid ""
 "Hooks can be used to trigger actions on certain events such as push / "
 "pull. They can trigger Python functions or external applications."
@@ -1737,25 +1675,6 b' msgstr "\xe3\x81\x99\xe3\x81\xb9\xe3\x81\xa6\xe3\x81\xae\xe3\x83\xaa\xe3\x83\x9d\xe3\x82\xb8\xe3\x83\x88\xe3\x83\xaa\xe3\x81\xae\xe3\x82\xad\xe3\x83\xa3\xe3\x83\x83\xe3\x82\xb7\xe3\x83\xa5\xe3\x82\x92\xe7\x84\xa1\xe5\x8a\xb9\xe5\x8c\x96\xe3\x81\x99\xe3\x82\x8b"'
 msgid "Install Git hooks"
 msgstr "Gitフックをインストール"
 
-msgid ""
-"Verify if Kallithea's Git hooks are installed for each repository. "
-"Current hooks will be updated to the latest version."
-msgstr ""
-"各リポジトリに Kallitheas の Gitフックがインストールされているか確認してく"
-"ださい。現在のフックは最新版に更新されます"
-
-msgid "Overwrite existing Git hooks"
-msgstr "既存のGitフックを上書きする"
-
-msgid ""
-"If installing Git hooks, overwrite any existing hooks, even if they do "
-"not seem to come from Kallithea. WARNING: This operation will destroy any "
-"custom git hooks you may have deployed by hand!"
-msgstr ""
-"GitフックをインストールするとKallitheaから設定されたものであっても既存の"
-"フックは全て上書きされます。警告: この操作はあなたが手動で配置したGitのカ"
-"スタムフックを全て破壊します!"
-
 msgid "Rescan Repositories"
 msgstr "リポジトリを再スキャン"
 
@@ -1811,16 +1730,6 b' msgstr "Mercurial\xe3\x82\xa8\xe3\x82\xaf\xe3\x82\xb9\xe3\x83\x86\xe3\x83\xb3\xe3\x82\xb7\xe3\x83\xa7\xe3\x83\xb3"'
 msgid "Enable largefiles extension"
 msgstr "largefilesエクステンションを有効にする"
 
-msgid "Enable hgsubversion extension"
-msgstr "hgsubversionエクステンションを有効にする"
-
-msgid ""
-"Requires hgsubversion library to be installed. Enables cloning of remote "
-"Subversion repositories while converting them to Mercurial."
-msgstr ""
-"hgsubversion ライブラリのインストールが必要です。リモートのSVNリポジトリを"
-"クローンしてMercurialリポジトリに変換するすることが可能です。"
-
 msgid "Location of repositories"
 msgstr "リポジトリの場所"
 
@@ -2166,7 +2075,7 b' msgstr "\xe3\x83\xaa\xe3\x83\x93\xe3\x82\xb8\xe3\x83\xa7\xe3\x83\xb3\xe3\x81\xaa\xe3\x81\x97"'
 msgid "Failed to revoke permission"
 msgstr "権限の取消に失敗しました"
 
-msgid "Confirm to revoke permission for {0}: {1} ?"
+msgid "Confirm to revoke permission for {0}: {1}?"
 msgstr "権限 {0}: {1} を取り消してもよろしいですか？"
 
 msgid "Select changeset"
@@ -2408,6 +2317,9 b' msgstr "%s \xe3\x83\x95\xe3\x82\xa1\xe3\x82\xa4\xe3\x83\xab\xe3\x81\xae\xe5\xb7\xae\xe5\x88\x86\xe3\x82\x92\xe4\xb8\xa6\xe3\x81\xb9\xe3\x81\xa6\xe8\xa1\xa8\xe7\xa4\xba"'
 msgid "File diff"
 msgstr "ファイル差分"
 
+msgid "Ignore whitespace"
+msgstr "空白を無視"
+
 msgid "%s File Diff"
 msgstr "%s ファイル差分"
 

kallithea/i18n/lb/LC_MESSAGES/kallithea.po

@@ -13,18 +13,15 b' msgstr ""'
 msgid "There are no changesets yet"
 msgstr "Et sinn nach keng Ännerungen do"
 
+msgid "SSH access is disabled."
+msgstr "SSH Accès ass ausgeschalt."
+
 msgid "None"
 msgstr "Keng"
 
 msgid "(closed)"
 msgstr "(Zou)"
 
-msgid "Show whitespace"
-msgstr "Leerzeechen uweisen"
-
-msgid "Ignore whitespace"
-msgstr "Leerzechen ignoréieren"
-
 msgid "No permission to change status"
 msgstr "Keng Erlabnis fir den Status ze änneren"
 
@@ -163,9 +160,6 b' msgstr "N\xc3\xa4ischt"'
 msgid "Please enter email address"
 msgstr "Wannechgelift E-Mail-Adress afügen"
 
-msgid "SSH access is disabled."
-msgstr "SSH Accès ass ausgeschalt."
-
 msgid "Binary file"
 msgstr "Binär Datei"
 
@@ -214,6 +208,9 b' msgstr "Keng \xc3\x84nnerungen"'
 msgid "No changesets yet"
 msgstr "Nach keng Ännerungen do"
 
+msgid "Ignore whitespace"
+msgstr "Leerzechen ignoréieren"
+
 msgid "There are no forks yet"
 msgstr "Et sinn nach keng Ofzweigungen do"
 

kallithea/i18n/nb_NO/LC_MESSAGES/kallithea.po

@@ -19,15 +19,6 b' msgstr "Ingen"'
 msgid "(closed)"
 msgstr "(lukket)"
 
-msgid "Show whitespace"
-msgstr "Vis blanktegn"
-
-msgid "Ignore whitespace"
-msgstr "Ignorer blanktegn"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Øk diff-bindeleddsinformasjon til %(num)s linjer"
-
 msgid "Successfully deleted pull request %s"
 msgstr "Slettet flettingsforespørsel %s"
 
@@ -436,6 +427,9 b' msgstr "Fjernet IP-adressen fra brukerhv'
 msgid "Binary file"
 msgstr "Binærfil"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Øk diff-bindeleddsinformasjon til %(num)s linjer"
+
 msgid "Fork name %s"
 msgstr "Forgreningsnavn %s"
 
@@ -517,9 +511,6 b' msgstr "%s og %s siden"'
 msgid "just now"
 msgstr "akkurat nå"
 
-msgid "on line %s"
-msgstr "på linje %s"
-
 msgid "top level"
 msgstr "toppnivå"
 
@@ -614,9 +605,12 b' msgstr "Brukernavn"'
 msgid "Password"
 msgstr "Passord"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "Glemt passordet ditt?"
 
+msgid "Don't have an account?"
+msgstr "Mangler du konto?"
+
 msgid "Password Reset"
 msgstr "Passordstilbakestilling"
 
@@ -1141,9 +1135,6 b' msgstr "Ikke innlogget"'
 msgid "Forgot password?"
 msgstr "Glemt passordet?"
 
-msgid "Don't have an account?"
-msgstr "Mangler du konto?"
-
 msgid "Log Out"
 msgstr "Logg ut"
 
@@ -1170,3 +1161,6 b' msgstr "Velg endringssett"'
 
 msgid "%s comments"
 msgstr "%s kommentarer"
+
+msgid "Ignore whitespace"
+msgstr "Ignorer blanktegn"

kallithea/i18n/nl_BE/LC_MESSAGES/kallithea.po

@@ -19,12 +19,6 b' msgstr "Geen"'
 msgid "(closed)"
 msgstr "(gesloten)"
 
-msgid "Show whitespace"
-msgstr "Toon witruimtes"
-
-msgid "Increase diff context to %(num)s lines"
-msgstr "Vergroot de diff context tot %(num)s lijnen"
-
 msgid "No permission to change status"
 msgstr "Geen toestemming om de status te veranderen"
 
@@ -203,6 +197,9 b' msgstr "SSH key succesvol verwijderd"'
 msgid "An error occurred during creation of field: %r"
 msgstr "Er is een fout opgetreden tijdens het aanmaken van veld: %r"
 
+msgid "Increase diff context to %(num)s lines"
+msgstr "Vergroot de diff context tot %(num)s lijnen"
+
 msgid "Changeset %s not found"
 msgstr "Changeset %s werd niet gevonden"
 

kallithea/i18n/pl/LC_MESSAGES/kallithea.po

@@ -11,21 +11,27 b' msgstr ""'
 "Plural-Forms: nplurals=3; plural=n==1 ? 0 : n%10>=2 && n%10<=4 && (n"
 "%100<10 || n%100>=20) ? 1 : 2;\n"
 
+msgid ""
+"CSRF token leak has been detected - all form tokens have been expired"
+msgstr ""
+"Wykryto wyciek tokenu CSRF — wszystkie tokeny formularza zostały "
+"unieważnione"
+
 msgid "There are no changesets yet"
 msgstr "Brak zestawienia zmian"
 
+msgid "Changeset for %s %s not found in %s"
+msgstr "Zmiany dla %s %s nie zostały znalezione w %s"
+
+msgid "SSH access is disabled."
+msgstr "Dostęp SSH jest wyłączony."
+
 msgid "None"
 msgstr "Brak"
 
 msgid "(closed)"
 msgstr "(zamknięty)"
 
-msgid "Show whitespace"
-msgstr "pokazuj spacje"
-
-msgid "Ignore whitespace"
-msgstr "Ignoruj pokazywanie spacji"
-
 msgid "Successfully deleted pull request %s"
 msgstr ""
 "Prośba o skasowanie połączenia gałęzi %s została wykonana prawidłowo"
@@ -170,9 +176,6 b' msgstr "Nieprawid\xc5\x82owy token resetowania has\xc5\x82a"'
 msgid "Successfully updated password"
 msgstr "Pomyślnie zaktualizowano hasło"
 
-msgid "Invalid reviewer \"%s\" specified"
-msgstr "Podano nieprawidłowego recenzenta \"%\""
-
 msgid "%s (closed)"
 msgstr "%s (zamknięty)"
 
@@ -444,12 +447,6 b' msgstr "Wyst\xc4\x85pi\xc5\x82 b\xc5\x82\xc4\x85d podczas usuwania z repozytorium statystyk"'
 msgid "Updated VCS settings"
 msgstr "Aktualizacja ustawień VCS"
 
-msgid ""
-"Unable to activate hgsubversion support. The \"hgsubversion\" library is "
-"missing"
-msgstr ""
-"Nie można włączyć obsługi hgsubversion. Brak biblioteki „hgsubversion”"
-
 msgid "Error occurred while updating application settings"
 msgstr "Wystąpił błąd podczas aktualizacji ustawień aplikacji"
 
@@ -551,18 +548,6 b' msgstr "Musisz by\xc4\x87 zarejestrowanym u\xc5\xbcytkownikiem, \xc5\xbceby wykona\xc4\x87 to dzia\xc5\x82anie"'
 msgid "You need to be signed in to view this page"
 msgstr "Musisz być zalogowany, żeby oglądać stronę"
 
-msgid ""
-"CSRF token leak has been detected - all form tokens have been expired"
-msgstr ""
-"Wykryto wyciek tokenu CSRF — wszystkie tokeny formularza zostały "
-"unieważnione"
-
-msgid "Changeset for %s %s not found in %s"
-msgstr "Zmiany dla %s %s nie zostały znalezione w %s"
-
-msgid "SSH access is disabled."
-msgstr "Dostęp SSH jest wyłączony."
-
 msgid "Binary file"
 msgstr "Plik binarny"
 
@@ -683,41 +668,9 b' msgstr "zmie\xc5\x84 nazw\xc4\x99"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"%s repozytorium nie jest mapowane do db może zostało utworzone lub "
-"zmienione z systemie plików proszę uruchomić aplikację ponownie, aby "
-"ponownie przeskanować repozytoria"
-
 msgid "SSH key is missing"
 msgstr "Brak klucza SSH"
 
-msgid ""
-"Incorrect SSH key - it must have both a key type and a base64 part, like "
-"'ssh-rsa ASRNeaZu4FA...xlJp='"
-msgstr ""
-"Nieprawidłowy klucz SSH - musi mieć zarówno typ, jak i część kodowaną "
-"base64, na przykład „ssh-rsa ASRNeaZu4FA ... xlJp=”"
-
-msgid "Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'"
-msgstr ""
-"Nieprawidłowy klucz SSH - musi zaczynać się od 'ssh-(rsa | dss | ed25519)'"
-
-msgid "Incorrect SSH key - unexpected characters in base64 part %r"
-msgstr ""
-"Nieprawidłowy klucz SSH - nieoczekiwane znaki w części kodowanej base64 %r"
-
-msgid "Incorrect SSH key - failed to decode base64 part %r"
-msgstr "Nieprawidłowy klucz SSH - nie udało się zdekodować części base64 %r"
-
-msgid "Incorrect SSH key - base64 part is not %r as claimed but %r"
-msgstr ""
-"Nieprawidłowy klucz SSH - część kodowana base64 nie jest %r jak podano, "
-"ale %r"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d rok"
@@ -769,12 +722,6 b' msgstr "%s i %s temu"'
 msgid "just now"
 msgstr "przed chwilą"
 
-msgid "on line %s"
-msgstr "widziany %s"
-
-msgid "[Mention]"
-msgstr "[Wymieniony]"
-
 msgid "top level"
 msgstr "najwyższy poziom"
 
@@ -822,13 +769,6 b' msgid "Default user has admin access to '
 msgstr ""
 "Domyślny użytkownik ma dostęp administracyjny do nowych grup użytkowników"
 
-msgid "Only admins can create repository groups"
-msgstr "Tylko administratorzy mogą tworzyć grupy repozytoriów"
-
-msgid "Non-admins can create repository groups"
-msgstr ""
-"Użytkownicy bez uprawnień administratora mogą tworzyć grupy repozytoriów"
-
 msgid "Only admins can create user groups"
 msgstr "Tylko administratorzy mogą tworzyć grupy użytkowników"
 
@@ -880,13 +820,6 b' msgstr "Wpisz %(min)i lub wi\xc4\x99cej znak\xc3\xb3w"'
 msgid "Name must not contain only digits"
 msgstr "Nazwa nie może zawierać samych cyfr"
 
-msgid ""
-"[Comment] %(repo_name)s changeset %(short_id)s \"%(message_short)s\" on "
-"%(branch)s"
-msgstr ""
-"[Komentarz] %(repo_name)s zmiana %(short_id)s \"%(message_short)s\" w "
-"%(branch)s"
-
 msgid "New user %(new_username)s registered"
 msgstr "Użytkownik %(new_username)s zarejestrował się"
 
@@ -902,9 +835,6 b' msgstr "Klucz SSH %s jest ju\xc5\xbc u\xc5\xbcywany przez %s"'
 msgid "SSH key with fingerprint %r found"
 msgstr "Znaleziono klucz SSH z odciskiem palca %r"
 
-msgid "New user registration"
-msgstr "nowy użytkownik się zarejestrował"
-
 msgid ""
 "You can't remove this user since it is crucial for the entire application"
 msgstr ""
@@ -989,13 +919,6 b' msgstr "Grupa repozytori\xc3\xb3w z nazw\xc4\x85 \\"%(repo)s\\" ju\xc5\xbc istnieje"'
 msgid "Invalid repository URL"
 msgstr "Nieprawidłowy adres URL repozytorium"
 
-msgid ""
-"Invalid repository URL. It must be a valid http, https, ssh, svn+http or "
-"svn+https URL"
-msgstr ""
-"Nieprawidłowy adres URL repozytorium. Musi to być prawidłowy adres URL "
-"typu http, https, ssh, svn + http lub svn + https"
-
 msgid "Fork has to be the same type as parent"
 msgstr "Fork musi być tego samego typu, jak rodzic"
 
@@ -1088,10 +1011,10 b' msgstr "Has\xc5\x82o"'
 msgid "Stay logged in after browser restart"
 msgstr "Pozostań zalogowany po ponownym uruchomieniu przeglądarki"
 
-msgid "Forgot your password ?"
+msgid "Forgot your password?"
 msgstr "Zapomniałeś hasła?"
 
-msgid "Don't have an account ?"
+msgid "Don't have an account?"
 msgstr "Nie masz konta?"
 
 msgid "Sign In"
@@ -1681,9 +1604,6 b' msgstr "Aktualizacja repozytorium po wys\xc5\x82aniu zmian (aktualizacja hg)"'
 msgid "Enable largefiles extension"
 msgstr "Rozszerzenia dużych plików"
 
-msgid "Enable hgsubversion extension"
-msgstr "Rozszerzenia hgsubversion"
-
 msgid ""
 "Click to unlock. You must restart Kallithea in order to make this setting "
 "take effect."
@@ -2034,6 +1954,9 b' msgstr "Pliki z list\xc4\x85 zmian i r\xc3\xb3\xc5\xbcnic: %s"'
 msgid "File diff"
 msgstr "Pliki różnic"
 
+msgid "Ignore whitespace"
+msgstr "Ignoruj pokazywanie spacji"
+
 msgid "%s File Diff"
 msgstr "%s Pliki różnic"
 

kallithea/i18n/pt/LC_MESSAGES/kallithea.po

@@ -19,12 +19,6 b' msgstr "Nenhum"'
 msgid "(closed)"
 msgstr "(fechado)"
 
-msgid "Show whitespace"
-msgstr "Mostrar espaços em branco"
-
-msgid "Ignore whitespace"
-msgstr "Ignorar espaços em branco"
-
 msgid ""
 "The request could not be understood by the server due to malformed syntax."
 msgstr ""
@@ -509,15 +503,6 b' msgstr "renomear"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"O repositório %s não está mapeado ao BD. Talvez ele tenha sido criado ou "
-"renomeado a partir do sistema de ficheiros. Por favor, execute a "
-"aplicação outra vez para varrer novamente por repositórios"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d ano"
@@ -563,12 +548,6 b' msgstr "%s e %s atr\xc3\xa1s"'
 msgid "just now"
 msgstr "agora há pouco"
 
-msgid "on line %s"
-msgstr "na linha %s"
-
-msgid "[Mention]"
-msgstr "[Menção]"
-
 msgid "top level"
 msgstr "nível superior"
 
@@ -596,9 +575,6 b' msgstr "Entre com %(min)i caracteres ou '
 msgid "latest tip"
 msgstr "tip mais recente"
 
-msgid "New user registration"
-msgstr "Novo registo de utilizador"
-
 msgid "Password reset link"
 msgstr "Ligação para trocar palavra-passe"
 
@@ -718,11 +694,11 b' msgstr "Nome de utilizador"'
 msgid "Password"
 msgstr "Palavra-passe"
 
-msgid "Forgot your password ?"
-msgstr "Esqueceu sua palavra-passe ?"
+msgid "Forgot your password?"
+msgstr "Esqueceu sua palavra-passe?"
 
-msgid "Don't have an account ?"
-msgstr "Não possui uma conta ?"
+msgid "Don't have an account?"
+msgstr "Não possui uma conta?"
 
 msgid "Sign In"
 msgstr "Entrar"
@@ -1011,9 +987,6 b' msgstr "Atualizar reposit\xc3\xb3rio ap\xc3\xb3s realizar push (hg update)"'
 msgid "Enable largefiles extension"
 msgstr "Ativar extensão largefiles"
 
-msgid "Enable hgsubversion extension"
-msgstr "Ativar extensão hgsubversion"
-
 msgid ""
 "Click to unlock. You must restart Kallithea in order to make this setting "
 "take effect."
@@ -1355,6 +1328,9 b' msgstr "Ficheiro %s diff lado-a-lado"'
 msgid "File diff"
 msgstr "Diff do ficheiro"
 
+msgid "Ignore whitespace"
+msgstr "Ignorar espaços em branco"
+
 msgid "%s File Diff"
 msgstr "%s Diff de Ficheiro"
 

kallithea/i18n/pt_BR/LC_MESSAGES/kallithea.po

@@ -19,12 +19,6 b' msgstr "Nenhum"'
 msgid "(closed)"
 msgstr "(fechado)"
 
-msgid "Show whitespace"
-msgstr "Mostrar espaços em branco"
-
-msgid "Ignore whitespace"
-msgstr "Ignorar espaços em branco"
-
 msgid ""
 "The request could not be understood by the server due to malformed syntax."
 msgstr ""
@@ -509,15 +503,6 b' msgstr "renomear"'
 msgid "chmod"
 msgstr "chmod"
 
-msgid ""
-"%s repository is not mapped to db perhaps it was created or renamed from "
-"the filesystem please run the application again in order to rescan "
-"repositories"
-msgstr ""
-"O repositório %s não está mapeado ao BD. Talvez ele tenha sido criado ou "
-"renomeado a partir do sistema de arquivos. Por favor, execute a aplicação "
-"outra vez para varrer novamente por repositórios"
-
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d ano"
@@ -563,12 +548,6 b' msgstr "%s e %s atr\xc3\xa1s"'
 msgid "just now"
 msgstr "agora há pouco"
 
-msgid "on line %s"
-msgstr "na linha %s"
-
-msgid "[Mention]"
-msgstr "[Menção]"
-
 msgid "top level"
 msgstr "nível superior"
 
@@ -596,9 +575,6 b' msgstr "Entre com %(min)i caracteres ou '
 msgid "latest tip"
 msgstr "tip mais recente"
 
-msgid "New user registration"
-msgstr "Novo registro de usuário"
-
 msgid "Password reset link"
 msgstr "Link para trocar senha"
 
@@ -718,11 +694,11 b' msgstr "Nome de usu\xc3\xa1rio"'
 msgid "Password"
 msgstr "Senha"
 
-msgid "Forgot your password ?"
-msgstr "Esqueceu sua senha ?"
+msgid "Forgot your password?"
+msgstr "Esqueceu sua senha?"
 
-msgid "Don't have an account ?"
-msgstr "Não possui uma conta ?"
+msgid "Don't have an account?"
+msgstr "Não possui uma conta?"
 
 msgid "Sign In"
 msgstr "Entrar"
@@ -1009,9 +985,6 b' msgstr "Atualizar reposit\xc3\xb3rio ap\xc3\xb3s realizar push (hg update)"'
 msgid "Enable largefiles extension"
 msgstr "Habilitar extensão largefiles"
 
-msgid "Enable hgsubversion extension"
-msgstr "Habilitar extensão hgsubversion"
-
 msgid ""
 "Click to unlock. You must restart Kallithea in order to make this setting "
 "take effect."
@@ -1353,6 +1326,9 b' msgstr "Arquivo %s diff lado-a-lado"'
 msgid "File diff"
 msgstr "Diff do arquivo"
 
+msgid "Ignore whitespace"
+msgstr "Ignorar espaços em branco"
+
 msgid "%s File Diff"
 msgstr "%s Diff de Arquivo"