.. _pytest-profiling: https://github.com/manahl/pytest-plugins/tree/master/pytest-profiling

.. _contributing-guidelines:

Contribution guidelines

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

Kallithea is GPLv3 and we assume all contributions are made by the

committer/contributor and under GPLv3 unless explicitly stated. We do care a

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.

Make sure to test your changes both manually and with the automatic tests

before posting.

We care about quality and review and keeping a clean repository history. We

might give feedback that requests polishing contributions until they are

"perfect". We might also rebase and collapse and make minor adjustments to your

changes when we apply them.

We try to make sure we have consensus on the direction the project is taking.

Everything non-sensitive should be discussed in public -- preferably on the

mailing list.  We aim at having all non-trivial changes reviewed by at least

one other core developer before pushing. Obvious non-controversial changes will

be handled more casually.

There is a main development branch ("default") which is generally stable so that

it can be (and is) used in production. There is also a "stable" branch that is

almost exclusively reserved for bug fixes or trivial changes. Experimental

changes should live elsewhere (for example in a pull request) until they are

ready.

.. _coding-guidelines:

Coding guidelines

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

We don't have a formal coding/formatting standard. We are currently using a mix

of Mercurial's (https://www.mercurial-scm.org/wiki/CodingStyle), pep8, and

consistency with existing code. Run ``scripts/run-all-cleanup`` before

committing to ensure some basic code formatting consistency.

We try to support the most common modern web browsers. IE9 is still supported

to the extent it is feasible, IE8 is not.

We primarily support Linux and OS X on the server side but Windows should also work.

HTML templates should use 2 spaces for indentation ... but be pragmatic. We

should use templates cleverly and avoid duplication. We should use reasonable

semantic markup with element classes and IDs that can be used for styling and testing.

We should only use inline styles in places where it really is semantic (such as

``display: none``).

JavaScript must use ``;`` between/after statements. Indentation 4 spaces. Inline

multiline functions should be indented two levels -- one for the ``()`` and one for

``{}``.

Variables holding jQuery objects should be named with a leading ``$``.

Commit messages should have a leading short line summarizing the changes. For

bug fixes, put ``(Issue #123)`` at the end of this line.

Use American English grammar and spelling overall. Use `English title case`_ for

page titles, button labels, headers, and 'labels' for fields in forms.

.. _English title case: https://en.wikipedia.org/wiki/Capitalization#Title_case

Template helpers (that is, everything in ``kallithea.lib.helpers``)

should only be referenced from templates. If you need to call a

helper from the Python code, consider moving the function somewhere

else (e.g. to the model).

Notes on the SQLAlchemy session

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Each HTTP request runs inside an independent SQLAlchemy session (as well

as in an independent database transaction). ``Session`` is the session manager

and factory. ``Session()`` will create a new session on-demand or return the

current session for the active thread. Many database operations are methods on

such session instances. The session will generally be removed by

TurboGears automatically.

Database model objects

(almost) always belong to a particular SQLAlchemy session, which means

that SQLAlchemy will ensure that they're kept in sync with the database

(but also means that they cannot be shared across requests).

Objects can be added to the session using ``Session().add``, but this is

rarely needed:

See the subsequent sections, the separate OS-specific instructions, and

: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

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

**Kallithea** is written entirely in Python_ and requires Python version

Given a Python installation, there are different ways of providing the

environment for running Python applications. Each of them pretty much

corresponds to a ``site-packages`` directory somewhere where packages can be

installed.

Kallithea itself can be run from source or be installed, but even when running

from source, there are some dependencies that must be installed in the Python

environment used for running Kallithea.

- Packages *could* be installed in Python's ``site-packages`` directory ... but

  that would require running pip_ as root and it would be hard to uninstall or

  upgrade and is probably not a good idea unless using a package manager.

- Packages could also be installed in ``~/.local`` ... but that is probably

  only a good idea if using a dedicated user per application or instance.

- Finally, it can be installed in a virtualenv. That is a very lightweight

  "container" where each Kallithea instance can get its own dedicated and

  self-contained virtual environment.

We recommend using virtualenv for installing Kallithea.

Locale environment

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

In order to ensure a correct functioning of Kallithea with respect to non-ASCII

characters in user names, file paths, commit messages, etc., it is very

important that Kallithea is run with a correct `locale` configuration.

On Unix, environment variables like ``LANG`` or ``LC_ALL`` can specify a language (like

``en_US``) and encoding (like ``UTF-8``) to use for code points outside the ASCII

range. The flexibility of supporting multiple encodings of Unicode has the flip

side of having to specify which encoding to use - especially for Mercurial.

It depends on the OS distribution and system configuration which locales are

available. For example, some Docker containers based on Debian default to only

supporting the ``C`` language, while other Linux environments have ``en_US`` but not

``C``. The ``locale -a`` command will show which values are available on the

current system. Regardless of the actual language, you should normally choose a

locale that has the ``UTF-8`` encoding (note that spellings ``utf8``, ``utf-8``,

``UTF8``, ``UTF-8`` are all referring to the same thing)

For technical reasons, the locale configuration **must** be provided in the

environment in which Kallithea runs - it cannot be specified in the ``.ini`` file.

How to practically do this depends on the web server that is used and the way it

is started. For example, gearbox is often started by a normal user, either

# -*- coding: utf-8 -*-

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

"""

kallithea

~~~~~~~~~

Kallithea, a web based repository management system.

Versioning implementation: http://www.python.org/dev/peps/pep-0386/

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 9, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, (C) 2014 Bradley M. Kuhn, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import platform

import sys

import celery

VERSION = (0, 7, 0)

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_APP = celery.Celery()  # needed at import time but is lazy and can be configured later

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 = {}

__version__ = '.'.join(str(each) for each in VERSION)

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = "Various Authors"

__url__ = 'https://kallithea-scm.org/'

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

import os

import platform

import re

import sys

import setuptools

# monkey patch setuptools to use distutils owner/group functionality

from setuptools.command import sdist

here = os.path.abspath(os.path.dirname(__file__))

def _get_meta_var(name, data, callback_handler=None):

    matches = re.compile(r'(?:%s)\s*=\s*(.*)' % name).search(data)

    if matches:

        s = eval(matches.groups()[0])

        if callable(callback_handler):

            return callback_handler(s)

        return s

_meta = open(os.path.join(here, 'kallithea', '__init__.py'), 'r')

_metadata = _meta.read()

_meta.close()

def callback(V):

    return '.'.join(map(str, V[:3])) + '.'.join(V[3:])

__version__ = _get_meta_var('VERSION', _metadata, callback)

__license__ = _get_meta_var('__license__', _metadata)

__author__ = _get_meta_var('__author__', _metadata)

__url__ = _get_meta_var('__url__', _metadata)

# defines current platform

__platform__ = platform.system()

is_windows = __platform__ in ['Windows']

requirements = [

    "alembic >= 1.0.10, < 1.15",

    "gearbox >= 0.1.0, < 1",

    "waitress >= 0.8.8, < 3.1",

    "WebOb >= 1.8, < 1.9",

    "backlash >= 0.1.2, < 1",

    "TurboGears2 >= 2.4, < 2.6",

    "tgext.routes >= 0.2.0, < 1",

    "Beaker >= 1.10.1, < 2",

    "WebHelpers2 >= 2.0, < 2.2",

    "FormEncode >= 1.3.1, < 2.2",

    "SQLAlchemy >= 1.2.9, < 1.4",  # TODO: Upgrade to 1.4 or 2 and fix code

    "Mako >= 0.9.1, < 1.4",

    "Pygments >= 2.2.0, < 2.8",  # TODO: Upgrade and update tests

    "Whoosh >= 2.7.1, < 2.8",

    "celery >= 5, < 5.6",

    "Babel >= 1.3, < 2.18",

    "python-dateutil >= 2.1.0, < 2.10",

    "Markdown >= 2.2.1, < 3.2",  # TODO: Upgrade and update tests

    "docutils >= 0.11, < 0.22",

    "URLObject >= 2.3.4, < 3.1",

    "Routes >= 2.0, < 2.6",

    "dulwich >= 0.19.0, < 0.25",

    "mercurial >= 5.2, < 7.2",

    "decorator >= 4.2.1, < 5.3",

    "Paste >= 2.0.3, < 3.11",

    "bleach >= 3.2, < 5",  # TODO: Upgrade and fix TypeError: clean() got an unexpected keyword argument 'styles'

    "Click >= 7.0, < 8.4",

    "ipaddr >= 2.2.0, < 2.3",

    "paginate >= 0.5, < 0.6",

    "paginate_sqlalchemy >= 0.3.0, < 0.4",

    "bcrypt >= 3.1.0, < 5.1",

    "pip >= 20.0, < 24.1",

    "chardet >= 3",

]

dependency_links = [

]

classifiers = [

    'Development Status :: 4 - Beta',

    'Environment :: Web Environment',

    'Framework :: Pylons',

    'Intended Audience :: Developers',

    'License :: OSI Approved :: GNU General Public License (GPL)',

    'Operating System :: OS Independent',

    'Topic :: Software Development :: Version Control',

]

# additional files from project that goes somewhere in the filesystem

# relative to sys.prefix

data_files = []

description = ('Kallithea is a fast and powerful management tool '

               'for Mercurial and Git with a built in push/pull server, '

               'full text search and code-review.')

keywords = ' '.join([

    'kallithea', 'mercurial', 'git', 'code review',

    'repo groups', 'ldap', 'repository management', 'hgweb replacement',

    'hgwebdir', 'gitweb replacement', 'serving hgweb',

])

# long description

README_FILE = 'README.rst'

try:

    long_description = open(README_FILE).read()

except IOError as err:

    sys.stderr.write(

        "[WARNING] Cannot find file specified as long_description (%s): %s\n"

        % (README_FILE, err)

    )

    long_description = description

sdist_org = sdist.sdist

class sdist_new(sdist_org):

    def initialize_options(self):

        sdist_org.initialize_options(self)

        self.owner = self.group = 'root'

sdist.sdist = sdist_new

packages = setuptools.find_packages(exclude=['ez_setup'])

setuptools.setup(

    name='Kallithea',

    version=__version__,

    description=description,

    long_description=long_description,

    keywords=keywords,

    license=__license__,

    author=__author__,

    author_email='kallithea@sfconservancy.org',