.. _changelog:

=========

Changelog

=========

1.5.0 (**2012-12-12**)

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

news

++++

- new rewritten from scratch diff engine. 10x faster in edge cases. Handling

  of file renames, copies, change flags and binary files

- added lightweight dashboard option. ref #500. New version of dashboard

  page that doesn't use any VCS data and is super fast to render. Recommended

  for large amount of repositories.

- implements #648 write Script for updating last modification time for

  lightweight dashboard

- implemented compare engine for git repositories.

- LDAP failover, option to specify multiple servers

- added Errormator and Sentry support for monitoring RhodeCode

- implemented #628: Pass server URL to rc-extensions hooks

- new tooltip implementation - added lazy loading of changesets from journal

  pages. This can significantly improve speed of rendering the page

- implements #632,added branch/tag/bookmarks info into feeds

  added changeset link to body of message

- implemented #638 permissions overview to groups

- implements #636, lazy loading of history and authors to speed up source

  pages rendering

    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:]))

__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

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

CELERY_EAGER = False

# link to config for pylons

CONFIG = {}

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

        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:

            return redirect(url('repos'))

        ##override defaults for exact repo info here git/hg etc

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

        c.landing_revs_choices = choices

        c.default_user_id = User.get_by_username('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()

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            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)) /

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session().commit()

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey') != -1:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete %s it still contains attached '

                          'forks') % repo_name,

                        category='warning')

            else:

                log.error(traceback.format_exc())

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

                          'deletion of %s') % repo_name,

                        category='error')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

class ForksController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(ForksController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

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

        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:

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('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()

        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 suffix to fork

        defaults['repo_name'] = '%s-fork' % defaults['repo_name']

        repo_id = c.rhodecode_db_repo.repo_id

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        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()

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

    @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:

            return redirect(url('home'))

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('forks/fork.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @NotAnonymous()

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

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

                                   'repository.admin')

    def fork_create(self, repo_name):

        self.__load_defaults()

        c.repo_info = Repository.get_by_repo_name(repo_name)

        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},

                             repo_groups=c.repo_groups_choices,

                             landing_revs=c.landing_revs_choices)()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

        bookmarks_group = ([('book:%s:%s' % (k, v), k) for

                         k, v in repo.bookmarks.iteritems()], _("Bookmarks"))

        tags_group = ([('tag:%s:%s' % (k, v), k) for

                         k, v in repo.tags.iteritems()], _("Tags"))

        hist_l.append(bookmarks_group)

        hist_l.append(branches_group)

        hist_l.append(tags_group)

        return hist_l

    def _get_default_rev(self, repo):

        """

        Get's default revision to do compare on pull request

        :param repo:

        """

        repo = repo.scm_instance

        if 'default' in repo.branches:

            return 'default'

        else:

            #if repo doesn't have default branch return first found

            return repo.branches.keys()[0]

    def show_all(self, repo_name):

        c.pull_requests = PullRequestModel().get_all(repo_name)

        c.repo_name = repo_name

        return render('/pullrequests/pullrequest_show_all.html')

    @NotAnonymous()

    def index(self):

        org_repo = c.rhodecode_db_repo

        if org_repo.scm_instance.alias != 'hg':

            log.error('Review not available for GIT REPOS')

            raise HTTPNotFound

        try:

            org_repo.scm_instance.get_changeset()

        except EmptyRepositoryError, e:

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=org_repo.repo_name))

        other_repos_info = {}

        c.org_refs = self._get_repo_refs(c.rhodecode_repo)

        c.org_repos = []

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            diff = diff_processor.as_html(enable_comments=enable_comments,

                                          parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], diff]

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.target_repo = c.pull_request.org_repo.repo_name

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

            cs_statuses[st.author.username] += [st]

        c.pull_request_reviewers = []

        c.pull_request_pending_reviewers = []

        for o in c.pull_request.reviewers:

            st = cs_statuses.get(o.user.username, None)

            if st:

                sorter = lambda k: k.version

                st = [(x, list(y)[0])

                      for x, y in (groupby(sorted(st, key=sorter), sorter))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            c.pull_request_reviewers.append([o.user, st])

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        except:

            log.error(traceback.format_exc())

            cur_status = 'undefined'

        if c.pull_request.is_closed() and 0:

            c.current_changeset_status = cur_status

        else:

            # changeset(pull-request) status calulation based on reviewers

            c.current_changeset_status = cs_model.calculate_status(

                                            c.pull_request_reviewers,

                                         )

        c.changeset_statuses = ChangesetStatus.STATUSES

        return render('/pullrequests/pullrequest_show.html')

    @NotAnonymous()

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

            pull_request=pull_request_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

        )

        # get status if set !

        if status and change_status:

            ChangesetStatusModel().set_status(

                c.rhodecode_db_repo.repo_id,

                status,

                c.rhodecode_user.user_id,

                comm,

                pull_request=pull_request_id

            )

        if request.POST.get('save_close'):

            PullRequestModel().close_pull_request(pull_request_id)

            action_logger(self.rhodecode_user,

                      'user_closed_pull_request:%s' % pull_request_id,

                      c.rhodecode_db_repo, self.ip_addr, self.sa)

        Session().commit()

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

            return redirect(h.url('pullrequest_show', repo_name=repo_name,

                                  pull_request_id=pull_request_id))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @NotAnonymous()

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if co.pull_request.is_closed():

            #don't allow deleting comments on closed pull request

        super(SettingsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

        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:

            return redirect(url('home'))

        ##override defaults for exact repo info here git/hg etc

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

        c.landing_revs_choices = choices

        defaults = RepoModel()._get_defaults(repo_name)

        return defaults

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasRepoPermissionAllDecorator('repository.admin')

    def update(self, repo_name):

        self.__load_defaults()

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            return redirect(url('home'))

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('admin_settings_my_account', anchor='my'))

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def toggle_locking(self, repo_name):

        """

        Toggle locking of repository by simple GET call to url

        :param repo_name:

        """

        try:

# English translations for rhodecode.

# Copyright (C) 2010 ORGANIZATION

# This file is distributed under the same license as the rhodecode project.

# FIRST AUTHOR <EMAIL@ADDRESS>, 2010.

#

msgid ""

msgstr ""

"Project-Id-Version: rhodecode 0.1\n"

"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"

"PO-Revision-Date: 2011-02-25 19:13+0100\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: en <LL@li.org>\n"

"Plural-Forms: nplurals=2; plural=(n != 1)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 0.9.6\n"

#: rhodecode/controllers/changelog.py:95

msgid "All Branches"

msgstr ""

msgid "show white space"

msgstr ""

msgid "ignore white space"

msgstr ""

#, python-format

msgid "%s line context"

msgstr ""

#, python-format

msgid "Status change -> %s"

msgstr ""

msgid ""

"Changing status on a changeset associated witha closed pull request is "

"not allowed"

msgstr ""

#: rhodecode/controllers/compare.py:75

#: rhodecode/controllers/shortlog.py:100

msgid "There are no changesets yet"

msgstr ""

#: rhodecode/controllers/error.py:69

msgid "Home page"

msgstr ""

#: rhodecode/controllers/error.py:98

msgid "The request could not be understood by the server due to malformed syntax."

msgstr ""

#: rhodecode/controllers/error.py:101

msgid "Unauthorized access to resource"

msgstr ""

#: rhodecode/controllers/error.py:103

msgid "You don't have permission to view this page"

msgstr ""

#: rhodecode/controllers/error.py:105

msgid "The resource could not be found"

msgstr ""

#: rhodecode/controllers/error.py:107

msgid ""

"The server encountered an unexpected condition which prevented it from "

"fulfilling the request."

msgstr ""

#: rhodecode/controllers/feed.py:52

#, python-format

msgid "Changes on %s repository"

msgstr ""

#: rhodecode/controllers/feed.py:53

#, python-format

msgid "%s %s feed"

msgstr ""

#: rhodecode/controllers/feed.py:86

#: rhodecode/templates/compare/compare_diff.html:62

#: rhodecode/templates/compare/compare_diff.html:73

#: rhodecode/templates/pullrequests/pullrequest_show.html:94

#: rhodecode/templates/pullrequests/pullrequest_show.html:153

msgid "Changeset was too big and was cut off..."

msgstr ""

#: rhodecode/controllers/feed.py:92

msgid "commited on"

msgstr ""

#: rhodecode/controllers/files.py:86

msgid "click here to add new file"

msgstr ""

#: rhodecode/controllers/files.py:87

#, python-format

msgid "There are no files yet %s"

msgstr ""

#: rhodecode/controllers/files.py:265 rhodecode/controllers/files.py:325

#, python-format

msgid "This repository is has been locked by %s on %s"

msgstr ""

#: rhodecode/controllers/files.py:404

msgid "downloads disabled"

msgstr ""

#: rhodecode/controllers/files.py:415

#, python-format

msgid "Unknown revision %s"

msgstr ""

#: rhodecode/controllers/files.py:417

msgid "Empty repository"

msgstr ""

#: rhodecode/controllers/files.py:419

msgid "Unknown archive type"

msgstr ""

#: rhodecode/controllers/files.py:564

#: rhodecode/templates/changeset/changeset_range.html:13

#: rhodecode/templates/changeset/changeset_range.html:31

msgid "Changesets"

msgstr ""

#: rhodecode/controllers/summary.py:236 rhodecode/model/scm.py:550

msgid "Branches"

msgstr ""

#: rhodecode/controllers/summary.py:237 rhodecode/model/scm.py:561

msgid "Tags"

msgstr ""

#, python-format

msgid "forked %s repository as %s"

msgstr ""

#, python-format

msgid "An error occurred during repository forking %s"

msgstr ""

msgid "public journal"

msgstr ""

#: rhodecode/templates/base/base.html:232