language: python

python:

  - "2.5"

  - "2.6"

  - "2.7"

env:  

  - TEST_DB=sqlite:////tmp/rhodecode_test.sqlite

  - TEST_DB=mysql://root@127.0.0.1/rhodecode_test

  - TEST_DB=postgresql://postgres@127.0.0.1/rhodecode_test

# command to install dependencies

before_script:

  - mysql -e 'create database rhodecode_test;'

  - psql -c 'create database rhodecode_test;' -U postgres

  - git --version

before_install:

  - sudo apt-get remove git

  - sudo add-apt-repository ppa:pdoes/ppa -y

  - sudo apt-get update -y

  - sudo apt-get install git -y

install:

  - pip install mysql-python psycopg2 mock unittest2

  - pip install . --use-mirrors

# command to run tests

script: nosetests

notifications:

    email:

        - marcinkuz@gmail.com

    irc: "irc.freenode.org#rhodecode"

    Marcin Kuźmiński <marcin@python-works.com>

    Lukasz Balcerzak <lukaszbalcerzak@gmail.com>

    Jason Harris <jason@jasonfharris.com>

    Thayne Harbaugh  <thayne@fusionio.com>

    cejones <>

    Thomas Waldmann <tw-public@gmx.de>

    Lorenzo M. Catucci <lorenzo@sancho.ccd.uniroma2.it>

    Dmitri Kuznetsov <>

    Jared Bunting <jared.bunting@peachjean.com>

    Steve Romanow <slestak989@gmail.com>

    Augosto Hermann <augusto.herrmann@planejamento.gov.br>    

    Ankit Solanki <ankit.solanki@gmail.com>    

    Liad Shani <liadff@gmail.com>

    Les Peabody <lpeabody@gmail.com>

    Jonas Oberschweiber <jonas.oberschweiber@d-velop.de>

    Matt Zuba <matt.zuba@goodwillaz.org>

    Aras Pranckevicius <aras@unity3d.com>

    Tony Bussieres <t.bussieres@gmail.com>

    Erwin Kroon <e.kroon@smartmetersolutions.nl>

    nansenat16 <nansenat16@null.tw>

    Vincent Duvert <vincent@duvert.net>

    Takumi IINO <trot.thunder@gmail.com>

    Indra Talip <indra.talip@gmail.com>

    James Rhodes <jrhodes@redpointsoftware.com.au>

use = egg:PasteDeploy#prefix

prefix = /<your-prefix>

[app:main]

use = egg:rhodecode

#filter-with = proxy-prefix

full_stack = true

static_files = true

# Optional Languages

# en, fr, ja, pt_BR, zh_CN, zh_TW

lang = en

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

app_instance_uuid = rc-develop

cut_off_limit = 256000

force_https = false

commit_parse_limit = 25

use_gravatar = true

## alternative_gravatar_url allows you to use your own avatar server application

## the following parts of the URL will be replaced

## {email}        user email

## {md5email}     md5 hash of the user email (like at gravatar.com)

## {size}         size of the image that is expected from the server application

#alternative_gravatar_url = http://myavatarserver.com/getbyemail/{email}/{size}

#alternative_gravatar_url = http://myavatarserver.com/getbymd5/{md5email}?s={size}

container_auth_enabled = false

proxypass_auth_enabled = false

default_encoding = utf8

## overwrite schema of clone url

## available vars:

## scheme - http/https

## user - current user

## pass - password 

## netloc - network location

## path - usually repo_name

#clone_uri = {scheme}://{user}{pass}{netloc}{path}

## issue tracking mapping for commits messages

## comment out issue_pat, issue_server, issue_prefix to enable

## pattern to get the issues from commit messages

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

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

.. _changelog:

=========

Changelog

=========

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

news

++++

- always put a comment about code-review status change even if user send

  empty data 

- modified_on column saves repository update and it's going to be used

  later for light version of main page ref #500

- pull request notifications send much nicer emails with details about pull

  request

- #551 show breadcrumbs in summary view for repositories inside a group

fixes

+++++

- fixed migrations of permissions that can lead to inconsistency.

  Some users sent feedback that after upgrading from older versions issues 

  with updating default permissions occurred. RhodeCode detects that now and

  resets default user permission to initial state if there is a need for that.

  Also forces users to set the default value for new forking permission. 

- #535 improved apache wsgi example configuration in docs

- fixes #550 mercurial repositories comparision failed when origin repo had

  additional not-common changesets

- fixed status of code-review in preview windows of pull request

.. _installation_win:

Step by step Installation for Windows

=====================================

RhodeCode step-by-step install Guide for Windows  

+ All Windows Updates until 24-may-2012 

Step1 - Install Visual Studio 2008 Express

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

Optional: You can also install MingW, but VS2008 installation is easier 

Download "Visual C++ 2008 Express Edition with SP1" from: 

http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express 

(if not found or relocated, google for "visual studio 2008 express" for 

updated link) 

You can also download full ISO file for offline installation, just 

choose "All - Offline Install ISO image file" in the previous page and 

choose "Visual C++ 2008 Express" when installing. 

.. note::

  Silverlight Runtime and SQL Server 2008 Express Edition are not 

  required, you can uncheck them 

Step2 - Install Python

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

use = egg:PasteDeploy#prefix

prefix = /<your-prefix>

[app:main]

use = egg:rhodecode

#filter-with = proxy-prefix

full_stack = true

static_files = true

# Optional Languages

# en, fr, ja, pt_BR, zh_CN, zh_TW

lang = en

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

app_instance_uuid = rc-production

cut_off_limit = 256000

force_https = false

commit_parse_limit = 50

use_gravatar = true

## alternative_gravatar_url allows you to use your own avatar server application

## the following parts of the URL will be replaced

## {email}        user email

## {md5email}     md5 hash of the user email (like at gravatar.com)

## {size}         size of the image that is expected from the server application

#alternative_gravatar_url = http://myavatarserver.com/getbyemail/{email}/{size}

#alternative_gravatar_url = http://myavatarserver.com/getbymd5/{md5email}?s={size}

container_auth_enabled = false

proxypass_auth_enabled = false

default_encoding = utf8

## overwrite schema of clone url

## available vars:

## scheme - http/https

## user - current user

## pass - password 

## netloc - network location

## path - usually repo_name

#clone_uri = {scheme}://{user}{pass}{netloc}{path}

## issue tracking mapping for commits messages

## comment out issue_pat, issue_server, issue_prefix to enable

## pattern to get the issues from commit messages

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

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

    RhodeCode, a web based repository management based on pylons

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

    :created_on: Apr 9, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

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

import sys

import platform

try:

    from rhodecode.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('dev%s' % _rev[0],)

except ImportError:

    pass

__version__ = ('.'.join((str(each) for each in VERSION[:3])) +

               '.'.join(VERSION[3:]))

__dbversion__ = 7  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = 'Marcin Kuzminski'

__url__ = 'http://rhodecode.org'

PLATFORM_WIN = ('Windows')

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD', 'OpenBSD', 'SunOS') #depracated

is_windows = __platform__ in PLATFORM_WIN

is_unix = not is_windows

use = egg:PasteDeploy#prefix

prefix = /<your-prefix>

[app:main]

use = egg:rhodecode

#filter-with = proxy-prefix

full_stack = true

static_files = true

# Optional Languages

# en, fr, ja, pt_BR, zh_CN, zh_TW

lang = en

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

app_instance_uuid = ${app_instance_uuid}

cut_off_limit = 256000

force_https = false

commit_parse_limit = 50

use_gravatar = true

## alternative_gravatar_url allows you to use your own avatar server application

## the following parts of the URL will be replaced

## {email}        user email

## {md5email}     md5 hash of the user email (like at gravatar.com)

## {size}         size of the image that is expected from the server application

#alternative_gravatar_url = http://myavatarserver.com/getbyemail/{email}/{size}

#alternative_gravatar_url = http://myavatarserver.com/getbymd5/{md5email}?s={size}

container_auth_enabled = false

proxypass_auth_enabled = false

default_encoding = utf8

## overwrite schema of clone url

## available vars:

## scheme - http/https

## user - current user

## pass - password 

## netloc - network location

## path - usually repo_name

#clone_uri = {scheme}://{user}{pass}{netloc}{path}

## issue tracking mapping for commits messages

## comment out issue_pat, issue_server, issue_prefix to enable

## pattern to get the issues from commit messages

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

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

        m.connect('delete_repo_users_group',

                  "/repos_delete_users_group/{repo_name:.*?}",

                  action="delete_perm_users_group",

                  conditions=dict(method=["DELETE"], function=check_repo))

        #settings actions

        m.connect('repo_stats', "/repos_stats/{repo_name:.*?}",

                  action="repo_stats", conditions=dict(method=["DELETE"],

                                                       function=check_repo))

        m.connect('repo_cache', "/repos_cache/{repo_name:.*?}",

                  action="repo_cache", conditions=dict(method=["DELETE"],

                                                       function=check_repo))

        m.connect('repo_public_journal', "/repos_public_journal/{repo_name:.*?}",

                  action="repo_public_journal", conditions=dict(method=["PUT"],

                                                        function=check_repo))

        m.connect('repo_pull', "/repo_pull/{repo_name:.*?}",

                  action="repo_pull", conditions=dict(method=["PUT"],

                                                      function=check_repo))

        m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*?}",

                  action="repo_as_fork", conditions=dict(method=["PUT"],

                                                      function=check_repo))

        m.connect('repo_locking', "/repo_locking/{repo_name:.*?}",

                  action="repo_locking", conditions=dict(method=["PUT"],

                                                      function=check_repo))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/repos_groups') as m:

        m.connect("repos_groups", "/repos_groups",

                  action="create", conditions=dict(method=["POST"]))

        m.connect("repos_groups", "/repos_groups",

                  action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos_groups", "/repos_groups.{format}",

                  action="index", conditions=dict(method=["GET"]))

        m.connect("new_repos_group", "/repos_groups/new",

                  action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repos_group", "/repos_groups/new.{format}",

                  action="new", conditions=dict(method=["GET"]))

        m.connect("update_repos_group", "/repos_groups/{id}",

                  action="update", conditions=dict(method=["PUT"],

                                                   function=check_int))

        m.connect("delete_repos_group", "/repos_groups/{id}",

                  action="delete", conditions=dict(method=["DELETE"],

                                                   function=check_int))

        m.connect("edit_repos_group", "/repos_groups/{id:.*?}/edit",

                  action="edit", conditions=dict(method=["GET"],))

        m.connect("formatted_edit_repos_group",

                  "/repos_groups/{id}.{format}/edit",

                  action="edit", conditions=dict(method=["GET"],

                                                 function=check_int))

                 controller='files', action='add', revision='tip',

                 f_path='', conditions=dict(function=check_repo))

    rmap.connect('files_archive_home', '/{repo_name:.*?}/archive/{fname}',

                controller='files', action='archivefile',

                conditions=dict(function=check_repo))

    rmap.connect('files_nodelist_home',

                 '/{repo_name:.*?}/nodelist/{revision}/{f_path:.*}',

                controller='files', action='nodelist',

                conditions=dict(function=check_repo))

    rmap.connect('repo_settings_delete', '/{repo_name:.*?}/settings',

                controller='settings', action="delete",

                conditions=dict(method=["DELETE"], function=check_repo))

    rmap.connect('repo_settings_update', '/{repo_name:.*?}/settings',

                controller='settings', action="update",

                conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect('repo_settings_home', '/{repo_name:.*?}/settings',

                controller='settings', action='index',

                conditions=dict(function=check_repo))

    rmap.connect('repo_fork_create_home', '/{repo_name:.*?}/fork',

                controller='forks', action='fork_create',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('repo_fork_home', '/{repo_name:.*?}/fork',

                controller='forks', action='fork',

                conditions=dict(function=check_repo))

    rmap.connect('repo_forks_home', '/{repo_name:.*?}/forks',

                 controller='forks', action='forks',

                 conditions=dict(function=check_repo))

    rmap.connect('repo_followers_home', '/{repo_name:.*?}/followers',

                 controller='followers', action='followers',

                 conditions=dict(function=check_repo))

    return rmap

    :license: GPLv3, see COPYING for more details.

"""

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

import logging

from pylons import request, tmpl_context as c

from sqlalchemy.orm import joinedload

from webhelpers.paginate import Page

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog

log = logging.getLogger(__name__)

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

        users_log = UserLog.query()\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))\

                .order_by(UserLog.action_date.desc())

        c.users_log = Page(users_log, page=p, items_per_page=10)

        c.log_data = render('admin/admin_log.html')

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.log_data

        return render('admin/admin.html')

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

import logging

import traceback

from pylons import request

from pylons import tmpl_context as c, url

from pylons.controllers.util import redirect

from webhelpers.paginate import Page

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib import helpers as h

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class NotificationsController(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('notification', 'notifications', controller='_admin/notifications',

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

    @NotAnonymous()

    def __before__(self):

        super(NotificationsController, self).__before__()

    def index(self, format='html'):

        """GET /_admin/notifications: All items in the collection"""

        # url('notifications')

        c.user = self.rhodecode_user

        notif = NotificationModel().get_for_user(self.rhodecode_user.user_id,

                                            filter_=request.GET.getall('type'))

        c.notifications = Page(notif, page=p, items_per_page=10)

        c.pull_request_type = Notification.TYPE_PULL_REQUEST

        c.comment_type = [Notification.TYPE_CHANGESET_COMMENT,

                          Notification.TYPE_PULL_REQUEST_COMMENT]

        _current_filter = request.GET.getall('type')

        c.current_filter = 'all'

        if _current_filter == [c.pull_request_type]:

            c.current_filter = 'pull_request'

        elif _current_filter == c.comment_type:

            c.current_filter = 'comment'

        return render('admin/notifications/notifications.html')

    def mark_all_read(self):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            nm = NotificationModel()

            # mark all read

            nm.mark_all_read_for_user(self.rhodecode_user.user_id,

                                      filter_=request.GET.getall('type'))

            Session().commit()

            c.user = self.rhodecode_user

            notif = nm.get_for_user(self.rhodecode_user.user_id,

                                    filter_=request.GET.getall('type'))

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.lib.compat import json

log = logging.getLogger(__name__)

class ReposController(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('repo', 'repos')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.landing_revs_choices = choices

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

            h.flash(_('%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') % repo_name,

        group_name = group_name.rstrip('/')

        id_ = RepoGroup.get_by_group_name(group_name)

        if id_:

            return self.show(id_.group_id)

        raise HTTPNotFound

    @HasReposGroupPermissionAnyDecorator('group.read', 'group.write',

                                         'group.admin')

    def show(self, id, format='html'):

        """GET /repos_groups/id: Show a specific item"""

        # url('repos_group', id=ID)

        c.group = RepoGroup.get_or_404(id)

        c.group_repos = c.group.repositories.all()

        #overwrite our cached list with current filter

        gr_filter = c.group_repos

        c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)

        c.repos_list = c.cached_repo_list

        c.repo_cnt = 0

            .filter(RepoGroup.group_parent_id == id).all()

        return render('admin/repos_groups/repos_groups.html')

    @HasPermissionAnyDecorator('hg.admin')

    def edit(self, id, format='html'):

        """GET /repos_groups/id/edit: Form to edit an existing item"""

        # url('edit_repos_group', id=ID)

        c.repos_group = ReposGroupModel()._get_repos_group(id)

        defaults = self.__load_data(c.repos_group.group_id)

        # we need to exclude this group from the group list for editing

        c.repo_groups = filter(lambda x: x[0] != c.repos_group.group_id,

                               c.repo_groups)

        return htmlfill.render(

            render('admin/repos_groups/repos_groups_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

                #HOOKS

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_UPDATE)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_UPDATE)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_REPO_SIZE)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_REPO_SIZE)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_PUSH)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_PUSH)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_PULL)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                 RhodeCodeUi.HOOK_PULL)]

                Session().add(sett)

                ## EXTENSIONS

                sett = RhodeCodeUi.get_by_key('largefiles')

                sett.ui_active = form_result[_f('extensions_largefiles')]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key('hgsubversion')

                sett.ui_active = form_result[_f('extensions_hgsubversion')]

                Session().add(sett)

#                sett = RhodeCodeUi.get_by_key('hggit')

#                sett.ui_active = form_result[_f('extensions_hggit')]

#                Session().add(sett)

                Session().commit()

                h.flash(_('Updated VCS settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'application settings'), category='error')

        if setting_id == 'hooks':

            ui_key = request.POST.get('new_hook_ui_key')

            ui_value = request.POST.get('new_hook_ui_value')

            try:

                if ui_value and ui_key:

                    RhodeCodeUi.create_or_update_hook(ui_key, ui_value)

                    h.flash(_('Added new hook'),

                            category='success')

                # check for edits

                update = False

            .filter(Repository.user_id == self.rhodecode_user.user_id)\

            .order_by(func.lower(Repository.repo_name))\

            .all()

        c.user_repos = ScmModel().get_repos(all_repos)

        return render('admin/users/user_edit_my_account_repos.html')

    @NotAnonymous()

    def my_account_my_pullrequests(self):

        c.my_pull_requests = PullRequest.query()\

                                .filter(PullRequest.user_id==

                                        self.rhodecode_user.user_id)\

                                .all()

        c.participate_in_pull_requests = \

            [x.pull_request for x in PullRequestReviewers.query()\

                                    .filter(PullRequestReviewers.user_id==

                                            self.rhodecode_user.user_id)\

                                    .all()]

        return render('admin/users/user_edit_my_account_pullrequests.html')

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

        return render('admin/repos/repo_add_create_repository.html')

    def _get_hg_ui_settings(self):

        ret = RhodeCodeUi.query().all()