.. _changelog:

=========

Changelog

=========

1.3.5 (**2012-XX-XX**)

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

:status: in-progress

:branch: beta

news

++++

- use ext_json for json module

fixes

+++++

- fixed dev-version marker for stable when served from source codes

1.3.4 (**2012-03-28**)

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

news

++++

- Whoosh logging is now controlled by the .ini files logging setup

- added clone-url into edit form on /settings page

- added help text into repo add/edit forms

- created rcextensions module with additional mappings (ref #322) and

  post push/pull/create repo hooks callbacks

- implemented #377 Users view for his own permissions on account page

- #399 added inheritance of permissions for users group on repos groups

- #401 repository group is automatically pre-selected when adding repos 

  inside a repository group

- added alternative HTTP 403 response when client failed to authenticate. Helps 

  solving issues with Mercurial and LDAP

- #402 removed group prefix from repository name when listing repositories 

  inside a group

- added gravatars into permission view and permissions autocomplete

- #347 when running multiple RhodeCode instances, properly invalidates cache 

  for all registered servers

# 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

import formencode

import traceback

from formencode import htmlfill

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.helpers import Page

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator, \

from rhodecode.lib.base import BaseRepoController, render

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

from rhodecode.model.repo import RepoModel

from rhodecode.model.forms import RepoForkForm

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(ForksController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

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

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision+1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        # add prefix to fork

        defaults['repo_name'] = 'fork-' + defaults['repo_name']

        return defaults

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def forks(self, repo_name):

        p = int(request.params.get('page', 1))

        repo_id = c.rhodecode_db_repo.repo_id

        c.forks_pager = Page(d, page=p, items_per_page=20)

        c.forks_data = render('/forks/forks_data.html')

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

            return c.forks_data

        return render('/forks/forks.html')

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def fork(self, repo_name):

        c.repo_info = Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the file system'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        defaults = self.__load_data(repo_name)

from rhodecode.tests import *

from rhodecode.model.db import Repository

class TestForksController(TestController):

    def test_index(self):

        self.log_user()

        repo_name = HG_REPO

        response = self.app.get(url(controller='forks', action='forks',

                                    repo_name=repo_name))

        self.assertTrue("""There are no forks yet""" in response.body)

    def test_index_with_fork(self):

        self.log_user()

        # create a fork

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        org_repo = Repository.get_by_repo_name(repo_name)

        response = self.app.post(url(controller='forks',

                                     action='fork_create',

                                    repo_name=repo_name),

                                    {'repo_name':fork_name,

                                     'repo_group':'',

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

        response = self.app.get(url(controller='forks', action='forks',

                                    repo_name=repo_name))

        self.assertTrue("""<a href="/%s/summary">"""

                         """vcs_test_hg_fork</a>""" % fork_name

                         in response.body)

        #remove this fork

        response = self.app.delete(url('repo', repo_name=fork_name))

    def test_z_fork_create(self):

        self.log_user()

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        org_repo = Repository.get_by_repo_name(repo_name)

        response = self.app.post(url(controller='forks', action='fork_create',

                                    repo_name=repo_name),

                                    {'repo_name':fork_name,

                                     'repo_group':'',

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

        #test if we have a message that fork is ok

        self.assertTrue('forked %s repository as %s' \

                      % (repo_name, fork_name) in response.session['flash'][0])

        #test if the fork was created in the database

        fork_repo = self.Session.query(Repository)\

            .filter(Repository.repo_name == fork_name).one()

        self.assertEqual(fork_repo.repo_name, fork_name)

        self.assertEqual(fork_repo.fork.repo_name, repo_name)

        #test if fork is visible in the list ?

        response = response.follow()

        # check if fork is marked as fork

        # wait for cache to expire

        import time

        time.sleep(10)

        response = self.app.get(url(controller='summary', action='index',

                                    repo_name=fork_name))

        self.assertTrue('Fork of %s' % repo_name in response.body)