syntax: glob

*.pyc

*.swp

*.sqlite

*.tox

*.egg-info

*.egg

*.mo

.eggs/

tarballcache/

syntax: regexp

^rcextensions

^build

^dist/

^docs/build/

^docs/_build/

^data$

^sql_dumps/

^\.settings$

^\.project$

^\.pydevproject$

^\.coverage$

^kallithea\.db$

^test\.db$

^Kallithea\.egg-info$

^my\.ini$

^fabfile.py

^\.idea$

include           Apache-License-2.0.txt

include           CONTRIBUTORS

include           COPYING

include           LICENSE-MERGELY.html

include           LICENSE.md

include           MIT-Permissive-License.txt

include           README.rst

include           development.ini

recursive-include docs *

recursive-include init.d *

include           kallithea/bin/ldap_sync.conf

include           kallithea/bin/template.ini.mako

include           kallithea/config/deployment.ini_tmpl

recursive-include kallithea/i18n *

recursive-include kallithea/lib/dbmigrate *.py_tmpl README migrate.cfg

recursive-include kallithea/public *

recursive-include kallithea/templates *

recursive-include kallithea/tests/fixtures *

recursive-include kallithea/tests/scripts *

include           kallithea/tests/vcs/aconfig

To get started with development::

        hg clone https://kallithea-scm.org/repos/kallithea

        cd kallithea

        virtualenv ../kallithea-venv

        source ../kallithea-venv/bin/activate

        python setup.py develop

        paster make-config Kallithea my.ini

        paster setup-db my.ini --user=user --email=user@example.com --password=password --repos=/tmp

        paster serve my.ini --reload &

        firefox http://127.0.0.1:5000/

You can also start out by forking https://bitbucket.org/conservancy/kallithea

on Bitbucket_ and create a local clone of your own fork.

Running tests

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

After finishing your changes make sure all tests pass cleanly. You can run

the testsuite running ``nosetests`` from the project root, or if you use tox

run ``tox`` for python2.6-2.7 with multiple database test.

It is possible to avoid recreating the full test database on each invocation of

the tests, thus eliminating the initial delay. To achieve this, run the tests as::

    KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests

    kill -9 $(cat test.pid)

You can run individual tests by specifying their path as argument to nosetests.

nosetests also has many more options, see `nosetests -h`. Some useful options

are::

    -x, --stop            Stop running tests after the first error or failure

    -s, --nocapture       Don't capture stdout (any stdout output will be

                          printed immediately) [NOSE_NOCAPTURE]

    --failed              Run the tests that failed in the last test run.

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

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

of Mercurial (http://mercurial.selenic.com/wiki/CodingStyle), pep8, and

consistency with existing code. Run whitespacecleanup.sh to avoid stupid

whitespace noise in your patches.

    msgfmt -f -c kallithea/i18n/<new_language_code>/LC_MESSAGES/<updated_file.po>

Finally, compile the translations::

    python setup.py compile_catalog -l <new_language_code>

Updating translations

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

Extract the latest versions of strings for translation by running::

    python setup.py extract_messages

Update the PO file by doing::

    python setup.py update_catalog -l <new_language_code>

Edit the new updated translation file. Repeat all steps after `init_catalog` step from

new translation instructions

Testing translations

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

    lang=<new_language_code>

Run Kallithea tests by executing::

    nosetests

import os

import sys

import logging

import pkg_resources

from paste.deploy import loadapp

import pylons.test

from pylons.i18n.translation import _get_translator

def pytest_configure():

    path = os.getcwd()

    sys.path.insert(0, path)

    pkg_resources.working_set.add_entry(path)

    # Disable INFO logging of test database creation, restore with NOTSET

    logging.disable(logging.INFO)

    logging.disable(logging.NOTSET)

    # Setup the config and app_globals, only works if we can get

    # to the config object

    conf = getattr(pylons.test.pylonsapp, 'config')

    if conf:

        pylons.config._push_object(conf)

        if 'pylons.app_globals' in conf:

            pylons.app_globals._push_object(conf['pylons.app_globals'])

    # Initialize a translator for tests that utilize i18n

    translator = _get_translator(pylons.config.get('lang'))

    pylons.translator._push_object(translator)

    return pylons.test.pylonsapp

# -*- 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.tests.other.manual_test_vcs_operations

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Test suite for making push/pull operations.

Run it in two terminals::

 KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests kallithea/tests/other/manual_test_vcs_operations.py

You must have git > 1.8.1 for tests to work fine

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: Dec 30, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

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

"""

import re

import tempfile

import time

from os.path import join as jn

from tempfile import _RandomNameSequence

from subprocess import Popen, PIPE

from kallithea.tests import *

from kallithea.model.db import User, Repository, UserIpMap, CacheInvalidation

from kallithea.model.meta import Session

[egg_info]

tag_build =

tag_svn_revision = 0

tag_date = 0

[nosetests]

verbose = True

verbosity = 2

detailed-errors = 1

nologcapture = 1

[pytest]

# only look for tests in kallithea/tests

python_files = kallithea/tests/**/test_*.py

addopts =

    # --verbose

    # show extra test summary info as specified by chars (f)ailed, (E)error, (s)skipped, (x)failed, (X)passed, (w)warnings.

    -rfEsxXw

    # Shorter scrollbacks; less stuff to scroll through

    --tb=short

[compile_catalog]

domain = kallithea

directory = kallithea/i18n

statistics = true

[extract_messages]

add_comments = TRANSLATORS:

output_file = kallithea/i18n/kallithea.pot

msgid-bugs-address = translations@kallithea-scm.org

copyright-holder = Various authors, licensing as GPLv3

no-wrap = true