comments: enabled resolution for general comments, and finalized how general comment is build

rhodecode/controllers/changeset.py

@@ -1,473 +1,475 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 commit controller for RhodeCode showing changes between commits
 """
 
 import logging
 
 from collections import defaultdict
 from webob.exc import HTTPForbidden, HTTPBadRequest, HTTPNotFound
 
 from pylons import tmpl_context as c, request, response
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 
 from rhodecode.lib import auth
 from rhodecode.lib import diffs, codeblocks
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 import rhodecode.lib.helpers as h
 from rhodecode.lib.utils import action_logger, jsonify
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, CommitDoesNotExistError, NodeDoesNotExistError)
 from rhodecode.model.db import ChangesetComment, ChangesetStatus
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 
 
 log = logging.getLogger(__name__)
 
 
 def _update_with_GET(params, GET):
     for k in ['diff1', 'diff2', 'diff']:
         params[k] += GET.getall(k)
 
 
 def get_ignore_ws(fid, GET):
     ig_ws_global = GET.get('ignorews')
     ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))
     if ig_ws:
         try:
             return int(ig_ws[0].split(':')[-1])
         except Exception:
             pass
     return ig_ws_global
 
 
 def _ignorews_url(GET, fileid=None):
     fileid = str(fileid) if fileid else None
     params = defaultdict(list)
     _update_with_GET(params, GET)
     label = _('Show whitespace')
     tooltiplbl = _('Show whitespace for all diffs')
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = get_line_ctx(fileid, GET)
 
     if ig_ws is None:
         params['ignorews'] += [1]
         label = _('Ignore whitespace')
         tooltiplbl = _('Ignore whitespace for all diffs')
     ctx_key = 'context'
     ctx_val = ln_ctx
 
     # if we have passed in ln_ctx pass it along to our params
     if ln_ctx:
         params[ctx_key] += [ctx_val]
 
     if fileid:
         params['anchor'] = 'a_' + fileid
     return h.link_to(label, h.url.current(**params), title=tooltiplbl, class_='tooltip')
 
 
 def get_line_ctx(fid, GET):
     ln_ctx_global = GET.get('context')
     if fid:
         ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))
     else:
         _ln_ctx = filter(lambda k: k.startswith('C'), GET)
         ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx  else ln_ctx_global
         if ln_ctx:
             ln_ctx = [ln_ctx]
 
     if ln_ctx:
         retval = ln_ctx[0].split(':')[-1]
     else:
         retval = ln_ctx_global
 
     try:
         return int(retval)
     except Exception:
         return 3
 
 
 def _context_url(GET, fileid=None):
     """
     Generates a url for context lines.
 
     :param fileid:
     """
 
     fileid = str(fileid) if fileid else None
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2
 
     params = defaultdict(list)
     _update_with_GET(params, GET)
 
     if ln_ctx > 0:
         params['context'] += [ln_ctx]
 
     if ig_ws:
         ig_ws_key = 'ignorews'
         ig_ws_val = 1
         params[ig_ws_key] += [ig_ws_val]
 
     lbl = _('Increase context')
     tooltiplbl = _('Increase context for all diffs')
 
     if fileid:
         params['anchor'] = 'a_' + fileid
     return h.link_to(lbl, h.url.current(**params), title=tooltiplbl, class_='tooltip')
 
 
 class ChangesetController(BaseRepoController):
 
     def __before__(self):
         super(ChangesetController, self).__before__()
         c.affected_files_cut_off = 60
 
     def _index(self, commit_id_range, method):
         c.ignorews_url = _ignorews_url
         c.context_url = _context_url
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
 
         # fetch global flags of ignore ws or context lines
         context_lcl = get_line_ctx('', request.GET)
         ign_whitespace_lcl = get_ignore_ws('', request.GET)
 
         # diff_limit will cut off the whole diff if the limit is applied
         # otherwise it will just hide the big files from the front-end
         diff_limit = self.cut_off_limit_diff
         file_limit = self.cut_off_limit_file
 
         # get ranges of commit ids if preset
         commit_range = commit_id_range.split('...')[:2]
 
         try:
             pre_load = ['affected_files', 'author', 'branch', 'date',
                         'message', 'parents']
 
             if len(commit_range) == 2:
                 commits = c.rhodecode_repo.get_commits(
                     start_id=commit_range[0], end_id=commit_range[1],
                     pre_load=pre_load)
                 commits = list(commits)
             else:
                 commits = [c.rhodecode_repo.get_commit(
                     commit_id=commit_id_range, pre_load=pre_load)]
 
             c.commit_ranges = commits
             if not c.commit_ranges:
                 raise RepositoryError(
                     'The commit range returned an empty result')
         except CommitDoesNotExistError:
             msg = _('No such commit exists for this repository')
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except Exception:
             log.exception("General failure")
             raise HTTPNotFound()
 
         c.changes = OrderedDict()
         c.lines_added = 0
         c.lines_deleted = 0
 
         # auto collapse if we have more than limit
         collapse_limit = diffs.DiffProcessor._collapse_commits_over
         c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
 
         c.commit_statuses = ChangesetStatus.STATUSES
         c.inline_comments = []
         c.files = []
 
         c.statuses = []
         c.comments = []
         if len(c.commit_ranges) == 1:
             commit = c.commit_ranges[0]
             c.comments = CommentsModel().get_comments(
                 c.rhodecode_db_repo.repo_id,
                 revision=commit.raw_id)
             c.statuses.append(ChangesetStatusModel().get_status(
                 c.rhodecode_db_repo.repo_id, commit.raw_id))
             # comments from PR
             statuses = ChangesetStatusModel().get_statuses(
                 c.rhodecode_db_repo.repo_id, commit.raw_id,
                 with_revisions=True)
             prs = set(st.pull_request for st in statuses
                       if st.pull_request is not None)
             # from associated statuses, check the pull requests, and
             # show comments from them
             for pr in prs:
                 c.comments.extend(pr.comments)
 
         # Iterate over ranges (default commit view is always one commit)
         for commit in c.commit_ranges:
             c.changes[commit.raw_id] = []
 
             commit2 = commit
             commit1 = commit.parents[0] if commit.parents else EmptyCommit()
 
             _diff = c.rhodecode_repo.get_diff(
                 commit1, commit2,
                 ignore_whitespace=ign_whitespace_lcl, context=context_lcl)
             diff_processor = diffs.DiffProcessor(
                 _diff, format='newdiff', diff_limit=diff_limit,
                 file_limit=file_limit, show_full_diff=fulldiff)
 
             commit_changes = OrderedDict()
             if method == 'show':
                 _parsed = diff_processor.prepare()
                 c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
 
                 _parsed = diff_processor.prepare()
 
                 def _node_getter(commit):
                     def get_node(fname):
                         try:
                             return commit.get_node(fname)
                         except NodeDoesNotExistError:
                             return None
                     return get_node
 
                 inline_comments = CommentsModel().get_inline_comments(
                     c.rhodecode_db_repo.repo_id, revision=commit.raw_id)
                 c.inline_cnt = CommentsModel().get_inline_comments_count(
                     inline_comments)
 
                 diffset = codeblocks.DiffSet(
                     repo_name=c.repo_name,
                     source_node_getter=_node_getter(commit1),
                     target_node_getter=_node_getter(commit2),
                     comments=inline_comments
                 ).render_patchset(_parsed, commit1.raw_id, commit2.raw_id)
                 c.changes[commit.raw_id] = diffset
             else:
                 # downloads/raw we only need RAW diff nothing else
                 diff = diff_processor.as_raw()
                 c.changes[commit.raw_id] = [None, None, None, None, diff, None, None]
 
         # sort comments by how they were generated
         c.comments = sorted(c.comments, key=lambda x: x.comment_id)
 
 
         if len(c.commit_ranges) == 1:
             c.commit = c.commit_ranges[0]
             c.parent_tmpl = ''.join(
                 '# Parent  %s\n' % x.raw_id for x in c.commit.parents)
         if method == 'download':
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s.diff' % commit_id_range[:12])
             return diff
         elif method == 'patch':
             response.content_type = 'text/plain'
             c.diff = safe_unicode(diff)
             return render('changeset/patch_changeset.mako')
         elif method == 'raw':
             response.content_type = 'text/plain'
             return diff
         elif method == 'show':
             if len(c.commit_ranges) == 1:
                 return render('changeset/changeset.mako')
             else:
                 c.ancestor = None
                 c.target_repo = c.rhodecode_db_repo
                 return render('changeset/changeset_range.mako')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, revision, method='show'):
         return self._index(revision, method=method)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changeset_raw(self, revision):
         return self._index(revision, method='raw')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changeset_patch(self, revision):
         return self._index(revision, method='patch')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changeset_download(self, revision):
         return self._index(revision, method='download')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def comment(self, repo_name, revision):
         commit_id = revision
         status = request.POST.get('changeset_status', None)
         text = request.POST.get('text')
         comment_type = request.POST.get('comment_type')
+        resolves_comment_id = request.POST.get('resolves_comment_id', None)
 
         if status:
             text = text or (_('Status change %(transition_icon)s %(status)s')
                             % {'transition_icon': '>',
                                'status': ChangesetStatus.get_status_lbl(status)})
 
         multi_commit_ids = filter(
             lambda s: s not in ['', None],
             request.POST.get('commit_ids', '').split(','),)
 
         commit_ids = multi_commit_ids or [commit_id]
         comment = None
         for current_id in filter(None, commit_ids):
             c.co = comment = CommentsModel().create(
                 text=text,
                 repo=c.rhodecode_db_repo.repo_id,
                 user=c.rhodecode_user.user_id,
                 commit_id=current_id,
                 f_path=request.POST.get('f_path'),
                 line_no=request.POST.get('line'),
                 status_change=(ChangesetStatus.get_status_lbl(status)
                                if status else None),
                 status_change_type=status,
-                comment_type=comment_type
+                comment_type=comment_type,
+                resolves_comment_id=resolves_comment_id
             )
             c.inline_comment = True if comment.line_no else False
 
             # get status if set !
             if status:
                 # if latest status was from pull request and it's closed
                 # disallow changing status !
                 # dont_allow_on_closed_pull_request = True !
 
                 try:
                     ChangesetStatusModel().set_status(
                         c.rhodecode_db_repo.repo_id,
                         status,
                         c.rhodecode_user.user_id,
                         comment,
                         revision=current_id,
                         dont_allow_on_closed_pull_request=True
                     )
                 except StatusChangeOnClosedPullRequestError:
                     msg = _('Changing the status of a commit associated with '
                             'a closed pull request is not allowed')
                     log.exception(msg)
                     h.flash(msg, category='warning')
                     return redirect(h.url(
                         'changeset_home', repo_name=repo_name,
                         revision=current_id))
 
         # finalize, commit and redirect
         Session().commit()
 
         data = {
             'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
         }
         if comment:
             data.update(comment.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.mako')})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     def preview_comment(self):
         # Technically a CSRF token is not needed as no state changes with this
         # call. However, as this is a POST is better to have it, so automated
         # tools don't flag it as potential CSRF.
         # Post is required because the payload could be bigger than the maximum
         # allowed by GET.
         if not request.environ.get('HTTP_X_PARTIAL_XHR'):
             raise HTTPBadRequest()
         text = request.POST.get('text')
         renderer = request.POST.get('renderer') or 'rst'
         if text:
             return h.render(text, renderer=renderer, mentions=True)
         return ''
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         comment = ChangesetComment.get(comment_id)
         owner = (comment.author.user_id == c.rhodecode_user.user_id)
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
         if h.HasPermissionAny('hg.admin')() or is_repo_admin or owner:
             CommentsModel().delete(comment=comment)
             Session().commit()
             return True
         else:
             raise HTTPForbidden()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_info(self, repo_name, revision):
         if request.is_xhr:
             try:
                 return c.rhodecode_repo.get_commit(commit_id=revision)
             except CommitDoesNotExistError as e:
                 return EmptyCommit(message=str(e))
         else:
             raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_children(self, repo_name, revision):
         if request.is_xhr:
             commit = c.rhodecode_repo.get_commit(commit_id=revision)
             result = {"results": commit.children}
             return result
         else:
             raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_parents(self, repo_name, revision):
         if request.is_xhr:
             commit = c.rhodecode_repo.get_commit(commit_id=revision)
             result = {"results": commit.parents}
             return result
         else:
             raise HTTPBadRequest()

rhodecode/controllers/pullrequests.py

@@ -1,1029 +1,1029 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 pull requests controller for rhodecode for initializing pull requests
 """
 import types
 
 import peppercorn
 import formencode
 import logging
 import collections
 
 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPBadRequest
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 from pyramid.threadlocal import get_current_registry
 from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import or_
 
 from rhodecode import events
 from rhodecode.lib import auth, diffs, helpers as h, codeblocks
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.base import (
     BaseRepoController, render, vcs_operation_context)
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasAcceptedRepoType, XHRRequired)
 from rhodecode.lib.channelstream import channelstream_request
 from rhodecode.lib.utils import jsonify
 from rhodecode.lib.utils2 import (
     safe_int, safe_str, str2bool, safe_unicode)
 from rhodecode.lib.vcs.backends.base import (
     EmptyCommit, UpdateFailureReason, EmptyRepository)
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
     NodeDoesNotExistError)
 
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment,
     Repository, PullRequestVersion)
 from rhodecode.model.forms import PullRequestForm
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 
 log = logging.getLogger(__name__)
 
 
 class PullrequestsController(BaseRepoController):
     def __before__(self):
         super(PullrequestsController, self).__before__()
 
     def _load_compare_data(self, pull_request, inline_comments):
         """
         Load context data needed for generating compare diff
 
         :param pull_request: object related to the request
         :param enable_comments: flag to determine if comments are included
         """
         source_repo = pull_request.source_repo
         source_ref_id = pull_request.source_ref_parts.commit_id
 
         target_repo = pull_request.target_repo
         target_ref_id = pull_request.target_ref_parts.commit_id
 
         # despite opening commits for bookmarks/branches/tags, we always
         # convert this to rev to prevent changes after bookmark or branch change
         c.source_ref_type = 'rev'
         c.source_ref = source_ref_id
 
         c.target_ref_type = 'rev'
         c.target_ref = target_ref_id
 
         c.source_repo = source_repo
         c.target_repo = target_repo
 
         c.fulldiff = bool(request.GET.get('fulldiff'))
 
         # diff_limit is the old behavior, will cut off the whole diff
         # if the limit is applied  otherwise will just hide the
         # big files from the front-end
         diff_limit = self.cut_off_limit_diff
         file_limit = self.cut_off_limit_file
 
         pre_load = ["author", "branch", "date", "message"]
 
         c.commit_ranges = []
         source_commit = EmptyCommit()
         target_commit = EmptyCommit()
         c.missing_requirements = False
         try:
             c.commit_ranges = [
                 source_repo.get_commit(commit_id=rev, pre_load=pre_load)
                 for rev in pull_request.revisions]
 
             c.statuses = source_repo.statuses(
                 [x.raw_id for x in c.commit_ranges])
 
             target_commit = source_repo.get_commit(
                 commit_id=safe_str(target_ref_id))
             source_commit = source_repo.get_commit(
                 commit_id=safe_str(source_ref_id))
         except RepositoryRequirementError:
             c.missing_requirements = True
 
         # auto collapse if we have more than limit
         collapse_limit = diffs.DiffProcessor._collapse_commits_over
         c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
 
         c.changes = {}
         c.missing_commits = False
         if (c.missing_requirements or
                 isinstance(source_commit, EmptyCommit) or
                     source_commit == target_commit):
             _parsed = []
             c.missing_commits = True
         else:
             vcs_diff = PullRequestModel().get_diff(pull_request)
             diff_processor = diffs.DiffProcessor(
                 vcs_diff, format='newdiff', diff_limit=diff_limit,
                 file_limit=file_limit, show_full_diff=c.fulldiff)
 
             _parsed = diff_processor.prepare()
             c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
 
             included_files = {}
             for f in _parsed:
                 included_files[f['filename']] = f['stats']
 
             c.deleted_files = [fname for fname in inline_comments if
                                fname not in included_files]
 
             c.deleted_files_comments = collections.defaultdict(dict)
             for fname, per_line_comments in inline_comments.items():
                 if fname in c.deleted_files:
                     c.deleted_files_comments[fname]['stats'] = 0
                     c.deleted_files_comments[fname]['comments'] = list()
                     for lno, comments in per_line_comments.items():
                         c.deleted_files_comments[fname]['comments'].extend(comments)
 
             def _node_getter(commit):
                 def get_node(fname):
                     try:
                         return commit.get_node(fname)
                     except NodeDoesNotExistError:
                         return None
                 return get_node
 
             c.diffset = codeblocks.DiffSet(
                 repo_name=c.repo_name,
                 source_repo_name=c.source_repo.repo_name,
                 source_node_getter=_node_getter(target_commit),
                 target_node_getter=_node_getter(source_commit),
                 comments=inline_comments
             ).render_patchset(_parsed, target_commit.raw_id, source_commit.raw_id)
 
     def _extract_ordering(self, request):
         column_index = safe_int(request.GET.get('order[0][column]'))
         order_dir = request.GET.get('order[0][dir]', 'desc')
         order_by = request.GET.get(
             'columns[%s][data][sort]' % column_index, 'name_raw')
         return order_by, order_dir
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     def show_all(self, repo_name):
         # filter types
         c.active = 'open'
         c.source = str2bool(request.GET.get('source'))
         c.closed = str2bool(request.GET.get('closed'))
         c.my = str2bool(request.GET.get('my'))
         c.awaiting_review = str2bool(request.GET.get('awaiting_review'))
         c.awaiting_my_review = str2bool(request.GET.get('awaiting_my_review'))
         c.repo_name = repo_name
 
         opened_by = None
         if c.my:
             c.active = 'my'
             opened_by = [c.rhodecode_user.user_id]
 
         statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
         if c.closed:
             c.active = 'closed'
             statuses = [PullRequest.STATUS_CLOSED]
 
         if c.awaiting_review and not c.source:
             c.active = 'awaiting'
         if c.source and not c.awaiting_review:
             c.active = 'source'
         if c.awaiting_my_review:
             c.active = 'awaiting_my'
 
         data = self._get_pull_requests_list(
             repo_name=repo_name, opened_by=opened_by, statuses=statuses)
         if not request.is_xhr:
             c.data = json.dumps(data['data'])
             c.records_total = data['recordsTotal']
             return render('/pullrequests/pullrequests.mako')
         else:
             return json.dumps(data)
 
     def _get_pull_requests_list(self, repo_name, opened_by, statuses):
         # pagination
         start = safe_int(request.GET.get('start'), 0)
         length = safe_int(request.GET.get('length'), c.visual.dashboard_items)
         order_by, order_dir = self._extract_ordering(request)
 
         if c.awaiting_review:
             pull_requests = PullRequestModel().get_awaiting_review(
                 repo_name, source=c.source, opened_by=opened_by,
                 statuses=statuses, offset=start, length=length,
                 order_by=order_by, order_dir=order_dir)
             pull_requests_total_count = PullRequestModel(
             ).count_awaiting_review(
                 repo_name, source=c.source, statuses=statuses,
                 opened_by=opened_by)
         elif c.awaiting_my_review:
             pull_requests = PullRequestModel().get_awaiting_my_review(
                 repo_name, source=c.source, opened_by=opened_by,
                 user_id=c.rhodecode_user.user_id, statuses=statuses,
                 offset=start, length=length, order_by=order_by,
                 order_dir=order_dir)
             pull_requests_total_count = PullRequestModel(
             ).count_awaiting_my_review(
                 repo_name, source=c.source, user_id=c.rhodecode_user.user_id,
                 statuses=statuses, opened_by=opened_by)
         else:
             pull_requests = PullRequestModel().get_all(
                 repo_name, source=c.source, opened_by=opened_by,
                 statuses=statuses, offset=start, length=length,
                 order_by=order_by, order_dir=order_dir)
             pull_requests_total_count = PullRequestModel().count_all(
                 repo_name, source=c.source, statuses=statuses,
                 opened_by=opened_by)
 
         from rhodecode.lib.utils import PartialRenderer
         _render = PartialRenderer('data_table/_dt_elements.mako')
         data = []
         for pr in pull_requests:
             comments = CommentsModel().get_all_comments(
                 c.rhodecode_db_repo.repo_id, pull_request=pr)
 
             data.append({
                 'name': _render('pullrequest_name',
                                 pr.pull_request_id, pr.target_repo.repo_name),
                 'name_raw': pr.pull_request_id,
                 'status': _render('pullrequest_status',
                                   pr.calculated_review_status()),
                 'title': _render(
                     'pullrequest_title', pr.title, pr.description),
                 'description': h.escape(pr.description),
                 'updated_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.updated_on)),
                 'updated_on_raw': h.datetime_to_time(pr.updated_on),
                 'created_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.created_on)),
                 'created_on_raw': h.datetime_to_time(pr.created_on),
                 'author': _render('pullrequest_author',
                                   pr.author.full_contact, ),
                 'author_raw': pr.author.full_name,
                 'comments': _render('pullrequest_comments', len(comments)),
                 'comments_raw': len(comments),
                 'closed': pr.is_closed(),
             })
         # json used to render the grid
         data = ({
             'data': data,
             'recordsTotal': pull_requests_total_count,
             'recordsFiltered': pull_requests_total_count,
         })
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     def index(self):
         source_repo = c.rhodecode_db_repo
 
         try:
             source_repo.scm_instance().get_commit()
         except EmptyRepositoryError:
             h.flash(h.literal(_('There are no commits yet')),
                     category='warning')
             redirect(url('summary_home', repo_name=source_repo.repo_name))
 
         commit_id = request.GET.get('commit')
         branch_ref = request.GET.get('branch')
         bookmark_ref = request.GET.get('bookmark')
 
         try:
             source_repo_data = PullRequestModel().generate_repo_data(
                 source_repo, commit_id=commit_id,
                 branch=branch_ref, bookmark=bookmark_ref)
         except CommitDoesNotExistError as e:
             log.exception(e)
             h.flash(_('Commit does not exist'), 'error')
             redirect(url('pullrequest_home', repo_name=source_repo.repo_name))
 
         default_target_repo = source_repo
 
         if source_repo.parent:
             parent_vcs_obj = source_repo.parent.scm_instance()
             if parent_vcs_obj and not parent_vcs_obj.is_empty():
                 # change default if we have a parent repo
                 default_target_repo = source_repo.parent
 
         target_repo_data = PullRequestModel().generate_repo_data(
             default_target_repo)
 
         selected_source_ref = source_repo_data['refs']['selected_ref']
 
         title_source_ref = selected_source_ref.split(':', 2)[1]
         c.default_title = PullRequestModel().generate_pullrequest_title(
             source=source_repo.repo_name,
             source_ref=title_source_ref,
             target=default_target_repo.repo_name
         )
 
         c.default_repo_data = {
             'source_repo_name': source_repo.repo_name,
             'source_refs_json': json.dumps(source_repo_data),
             'target_repo_name': default_target_repo.repo_name,
             'target_refs_json': json.dumps(target_repo_data),
         }
         c.default_source_ref = selected_source_ref
 
         return render('/pullrequests/pullrequest.mako')
 
     @LoginRequired()
     @NotAnonymous()
     @XHRRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def get_repo_refs(self, repo_name, target_repo_name):
         repo = Repository.get_by_repo_name(target_repo_name)
         if not repo:
             raise HTTPNotFound
         return PullRequestModel().generate_repo_data(repo)
 
     @LoginRequired()
     @NotAnonymous()
     @XHRRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def get_repo_destinations(self, repo_name):
         repo = Repository.get_by_repo_name(repo_name)
         if not repo:
             raise HTTPNotFound
         filter_query = request.GET.get('query')
 
         query = Repository.query() \
             .order_by(func.length(Repository.repo_name)) \
             .filter(or_(
             Repository.repo_name == repo.repo_name,
             Repository.fork_id == repo.repo_id))
 
         if filter_query:
             ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
             query = query.filter(
                 Repository.repo_name.ilike(ilike_expression))
 
         add_parent = False
         if repo.parent:
             if filter_query in repo.parent.repo_name:
                 parent_vcs_obj = repo.parent.scm_instance()
                 if parent_vcs_obj and not parent_vcs_obj.is_empty():
                     add_parent = True
 
         limit = 20 - 1 if add_parent else 20
         all_repos = query.limit(limit).all()
         if add_parent:
             all_repos += [repo.parent]
 
         repos = []
         for obj in self.scm_model.get_repos(all_repos):
             repos.append({
                 'id': obj['name'],
                 'text': obj['name'],
                 'type': 'repo',
                 'obj': obj['dbrepo']
             })
 
         data = {
             'more': False,
             'results': [{
                 'text': _('Repositories'),
                 'children': repos
             }] if repos else []
         }
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @HasAcceptedRepoType('git', 'hg')
     @auth.CSRFRequired()
     def create(self, repo_name):
         repo = Repository.get_by_repo_name(repo_name)
         if not repo:
             raise HTTPNotFound
 
         controls = peppercorn.parse(request.POST.items())
 
         try:
             _form = PullRequestForm(repo.repo_id)().to_python(controls)
         except formencode.Invalid as errors:
             if errors.error_dict.get('revisions'):
                 msg = 'Revisions: %s' % errors.error_dict['revisions']
             elif errors.error_dict.get('pullrequest_title'):
                 msg = _('Pull request requires a title with min. 3 chars')
             else:
                 msg = _('Error creating pull request: {}').format(errors)
             log.exception(msg)
             h.flash(msg, 'error')
 
             # would rather just go back to form ...
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         source_repo = _form['source_repo']
         source_ref = _form['source_ref']
         target_repo = _form['target_repo']
         target_ref = _form['target_ref']
         commit_ids = _form['revisions'][::-1]
         reviewers = [
             (r['user_id'], r['reasons']) for r in _form['review_members']]
 
         # find the ancestor for this pr
         source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
         target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
 
         source_scm = source_db_repo.scm_instance()
         target_scm = target_db_repo.scm_instance()
 
         source_commit = source_scm.get_commit(source_ref.split(':')[-1])
         target_commit = target_scm.get_commit(target_ref.split(':')[-1])
 
         ancestor = source_scm.get_common_ancestor(
             source_commit.raw_id, target_commit.raw_id, target_scm)
 
         target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
         target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
 
         pullrequest_title = _form['pullrequest_title']
         title_source_ref = source_ref.split(':', 2)[1]
         if not pullrequest_title:
             pullrequest_title = PullRequestModel().generate_pullrequest_title(
                 source=source_repo,
                 source_ref=title_source_ref,
                 target=target_repo
             )
 
         description = _form['pullrequest_desc']
         try:
             pull_request = PullRequestModel().create(
                 c.rhodecode_user.user_id, source_repo, source_ref, target_repo,
                 target_ref, commit_ids, reviewers, pullrequest_title,
                 description
             )
             Session().commit()
             h.flash(_('Successfully opened new pull request'),
                     category='success')
         except Exception as e:
             msg = _('Error occurred during sending pull request')
             log.exception(msg)
             h.flash(msg, category='error')
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         return redirect(url('pullrequest_show', repo_name=target_repo,
                             pull_request_id=pull_request.pull_request_id))
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def update(self, repo_name, pull_request_id):
         pull_request_id = safe_int(pull_request_id)
         pull_request = PullRequest.get_or_404(pull_request_id)
         # only owner or admin can update it
         allowed_to_update = PullRequestModel().check_user_update(
             pull_request, c.rhodecode_user)
         if allowed_to_update:
             controls = peppercorn.parse(request.POST.items())
 
             if 'review_members' in controls:
                 self._update_reviewers(
                     pull_request_id, controls['review_members'])
             elif str2bool(request.POST.get('update_commits', 'false')):
                 self._update_commits(pull_request)
             elif str2bool(request.POST.get('close_pull_request', 'false')):
                 self._reject_close(pull_request)
             elif str2bool(request.POST.get('edit_pull_request', 'false')):
                 self._edit_pull_request(pull_request)
             else:
                 raise HTTPBadRequest()
             return True
         raise HTTPForbidden()
 
     def _edit_pull_request(self, pull_request):
         try:
             PullRequestModel().edit(
                 pull_request, request.POST.get('title'),
                 request.POST.get('description'))
         except ValueError:
             msg = _(u'Cannot update closed pull requests.')
             h.flash(msg, category='error')
             return
         else:
             Session().commit()
 
         msg = _(u'Pull request title & description updated.')
         h.flash(msg, category='success')
         return
 
     def _update_commits(self, pull_request):
         resp = PullRequestModel().update_commits(pull_request)
 
         if resp.executed:
             msg = _(
                 u'Pull request updated to "{source_commit_id}" with '
                 u'{count_added} added, {count_removed} removed commits.')
             msg = msg.format(
                 source_commit_id=pull_request.source_ref_parts.commit_id,
                 count_added=len(resp.changes.added),
                 count_removed=len(resp.changes.removed))
             h.flash(msg, category='success')
 
             registry = get_current_registry()
             rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
             channelstream_config = rhodecode_plugins.get('channelstream', {})
             if channelstream_config.get('enabled'):
                 message = msg + (
                     ' - <a onclick="window.location.reload()">'
                     '<strong>{}</strong></a>'.format(_('Reload page')))
                 channel = '/repo${}$/pr/{}'.format(
                     pull_request.target_repo.repo_name,
                     pull_request.pull_request_id
                 )
                 payload = {
                     'type': 'message',
                     'user': 'system',
                     'exclude_users': [request.user.username],
                     'channel': channel,
                     'message': {
                         'message': message,
                         'level': 'success',
                         'topic': '/notifications'
                     }
                 }
                 channelstream_request(
                     channelstream_config, [payload], '/message',
                     raise_exc=False)
         else:
             msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
             warning_reasons = [
                 UpdateFailureReason.NO_CHANGE,
                 UpdateFailureReason.WRONG_REF_TPYE,
             ]
             category = 'warning' if resp.reason in warning_reasons else 'error'
             h.flash(msg, category=category)
 
     @auth.CSRFRequired()
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def merge(self, repo_name, pull_request_id):
         """
         POST /{repo_name}/pull-request/{pull_request_id}
 
         Merge will perform a server-side merge of the specified
         pull request, if the pull request is approved and mergeable.
         After succesfull merging, the pull request is automatically
         closed, with a relevant comment.
         """
         pull_request_id = safe_int(pull_request_id)
         pull_request = PullRequest.get_or_404(pull_request_id)
         user = c.rhodecode_user
 
         if self._meets_merge_pre_conditions(pull_request, user):
             log.debug("Pre-conditions checked, trying to merge.")
             extras = vcs_operation_context(
                 request.environ, repo_name=pull_request.target_repo.repo_name,
                 username=user.username, action='push',
                 scm=pull_request.target_repo.repo_type)
             self._merge_pull_request(pull_request, user, extras)
 
         return redirect(url(
             'pullrequest_show',
             repo_name=pull_request.target_repo.repo_name,
             pull_request_id=pull_request.pull_request_id))
 
     def _meets_merge_pre_conditions(self, pull_request, user):
         if not PullRequestModel().check_user_merge(pull_request, user):
             raise HTTPForbidden()
 
         merge_status, msg = PullRequestModel().merge_status(pull_request)
         if not merge_status:
             log.debug("Cannot merge, not mergeable.")
             h.flash(msg, category='error')
             return False
 
         if (pull_request.calculated_review_status()
             is not ChangesetStatus.STATUS_APPROVED):
             log.debug("Cannot merge, approval is pending.")
             msg = _('Pull request reviewer approval is pending.')
             h.flash(msg, category='error')
             return False
         return True
 
     def _merge_pull_request(self, pull_request, user, extras):
         merge_resp = PullRequestModel().merge(
             pull_request, user, extras=extras)
 
         if merge_resp.executed:
             log.debug("The merge was successful, closing the pull request.")
             PullRequestModel().close_pull_request(
                 pull_request.pull_request_id, user)
             Session().commit()
             msg = _('Pull request was successfully merged and closed.')
             h.flash(msg, category='success')
         else:
             log.debug(
                 "The merge was not successful. Merge response: %s",
                 merge_resp)
             msg = PullRequestModel().merge_status_message(
                 merge_resp.failure_reason)
             h.flash(msg, category='error')
 
     def _update_reviewers(self, pull_request_id, review_members):
         reviewers = [
             (int(r['user_id']), r['reasons']) for r in review_members]
         PullRequestModel().update_reviewers(pull_request_id, reviewers)
         Session().commit()
 
     def _reject_close(self, pull_request):
         if pull_request.is_closed():
             raise HTTPForbidden()
 
         PullRequestModel().close_pull_request_with_comment(
             pull_request, c.rhodecode_user, c.rhodecode_db_repo)
         Session().commit()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def delete(self, repo_name, pull_request_id):
         pull_request_id = safe_int(pull_request_id)
         pull_request = PullRequest.get_or_404(pull_request_id)
         # only owner can delete it !
         if pull_request.author.user_id == c.rhodecode_user.user_id:
             PullRequestModel().delete(pull_request)
             Session().commit()
             h.flash(_('Successfully deleted pull request'),
                     category='success')
             return redirect(url('my_account_pullrequests'))
         raise HTTPForbidden()
 
     def _get_pr_version(self, pull_request_id, version=None):
         pull_request_id = safe_int(pull_request_id)
         at_version = None
 
         if version and version == 'latest':
             pull_request_ver = PullRequest.get(pull_request_id)
             pull_request_obj = pull_request_ver
             _org_pull_request_obj = pull_request_obj
             at_version = 'latest'
         elif version:
             pull_request_ver = PullRequestVersion.get_or_404(version)
             pull_request_obj = pull_request_ver
             _org_pull_request_obj = pull_request_ver.pull_request
             at_version = pull_request_ver.pull_request_version_id
         else:
             _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(pull_request_id)
 
         pull_request_display_obj = PullRequest.get_pr_display_object(
             pull_request_obj, _org_pull_request_obj)
         return _org_pull_request_obj, pull_request_obj, \
                pull_request_display_obj, at_version
 
     def _get_pr_version_changes(self, version, pull_request_latest):
         """
         Generate changes commits, and diff data based on the current pr version
         """
 
         #TODO(marcink): save those changes as JSON metadata for chaching later.
 
         # fake the version to add the "initial" state object
         pull_request_initial = PullRequest.get_pr_display_object(
             pull_request_latest, pull_request_latest,
             internal_methods=['get_commit', 'versions'])
         pull_request_initial.revisions = []
         pull_request_initial.source_repo.get_commit = types.MethodType(
             lambda *a, **k: EmptyCommit(), pull_request_initial)
         pull_request_initial.source_repo.scm_instance = types.MethodType(
             lambda *a, **k: EmptyRepository(), pull_request_initial)
 
         _changes_versions = [pull_request_latest] + \
                             list(reversed(c.versions)) + \
                             [pull_request_initial]
 
         if version == 'latest':
             index = 0
         else:
             for pos, prver in enumerate(_changes_versions):
                 ver = getattr(prver, 'pull_request_version_id', -1)
                 if ver == safe_int(version):
                     index = pos
                     break
             else:
                 index = 0
 
         cur_obj = _changes_versions[index]
         prev_obj = _changes_versions[index + 1]
 
         old_commit_ids = set(prev_obj.revisions)
         new_commit_ids = set(cur_obj.revisions)
 
         changes = PullRequestModel()._calculate_commit_id_changes(
             old_commit_ids, new_commit_ids)
 
         old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(
             cur_obj, prev_obj)
         file_changes = PullRequestModel()._calculate_file_changes(
             old_diff_data, new_diff_data)
         return changes, file_changes
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def show(self, repo_name, pull_request_id):
         pull_request_id = safe_int(pull_request_id)
         version = request.GET.get('version')
 
         (pull_request_latest,
          pull_request_at_ver,
          pull_request_display_obj,
          at_version) = self._get_pr_version(pull_request_id, version=version)
 
         c.template_context['pull_request_data']['pull_request_id'] = \
             pull_request_id
 
         # pull_requests repo_name we opened it against
         # ie. target_repo must match
         if repo_name != pull_request_at_ver.target_repo.repo_name:
             raise HTTPNotFound
 
         c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
             pull_request_at_ver)
 
         pr_closed = pull_request_latest.is_closed()
         if at_version and not at_version == 'latest':
             c.allowed_to_change_status = False
             c.allowed_to_update = False
             c.allowed_to_merge = False
             c.allowed_to_delete = False
             c.allowed_to_comment = False
         else:
             c.allowed_to_change_status = PullRequestModel(). \
                 check_user_change_status(pull_request_at_ver, c.rhodecode_user)
             c.allowed_to_update = PullRequestModel().check_user_update(
                 pull_request_latest, c.rhodecode_user) and not pr_closed
             c.allowed_to_merge = PullRequestModel().check_user_merge(
                 pull_request_latest, c.rhodecode_user) and not pr_closed
             c.allowed_to_delete = PullRequestModel().check_user_delete(
                 pull_request_latest, c.rhodecode_user) and not pr_closed
             c.allowed_to_comment = not pr_closed
 
         cc_model = CommentsModel()
 
         c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
         c.pull_request_review_status = pull_request_at_ver.calculated_review_status()
         c.pr_merge_status, c.pr_merge_msg = PullRequestModel().merge_status(
             pull_request_at_ver)
         c.approval_msg = None
         if c.pull_request_review_status != ChangesetStatus.STATUS_APPROVED:
             c.approval_msg = _('Reviewer approval is pending.')
             c.pr_merge_status = False
 
         # inline comments
         inline_comments = cc_model.get_inline_comments(
             c.rhodecode_db_repo.repo_id, pull_request=pull_request_id)
 
         _inline_cnt, c.inline_versions = cc_model.get_inline_comments_count(
             inline_comments, version=at_version, include_aggregates=True)
 
         c.versions = pull_request_display_obj.versions()
         c.at_version_num = at_version if at_version and at_version != 'latest' else None
         c.at_version_pos = ChangesetComment.get_index_from_version(
             c.at_version_num, c.versions)
 
         is_outdated = lambda co: \
             not c.at_version_num \
             or co.pull_request_version_id <= c.at_version_num
 
         # inline_comments_until_version
         if c.at_version_num:
             # if we use version, then do not show later comments
             # than current version
             paths = collections.defaultdict(lambda: collections.defaultdict(list))
             for fname, per_line_comments in inline_comments.iteritems():
                 for lno, comments in per_line_comments.iteritems():
                     for co in comments:
                         if co.pull_request_version_id and is_outdated(co):
                             paths[co.f_path][co.line_no].append(co)
             inline_comments = paths
 
         # outdated comments
         c.outdated_cnt = 0
         if CommentsModel.use_outdated_comments(pull_request_latest):
             outdated_comments = cc_model.get_outdated_comments(
                 c.rhodecode_db_repo.repo_id,
                 pull_request=pull_request_at_ver)
 
             # Count outdated comments and check for deleted files
             is_outdated = lambda co: \
                 not c.at_version_num \
                 or co.pull_request_version_id < c.at_version_num
             for file_name, lines in outdated_comments.iteritems():
                 for comments in lines.values():
                     comments = [comm for comm in comments if is_outdated(comm)]
                     c.outdated_cnt += len(comments)
 
         # load compare data into template context
         self._load_compare_data(pull_request_at_ver, inline_comments)
 
         # this is a hack to properly display links, when creating PR, the
         # compare view and others uses different notation, and
         # compare_commits.mako renders links based on the target_repo.
         # We need to swap that here to generate it properly on the html side
         c.target_repo = c.source_repo
 
         # general comments
         c.comments = cc_model.get_comments(
             c.rhodecode_db_repo.repo_id, pull_request=pull_request_id)
 
         if c.allowed_to_update:
             force_close = ('forced_closed', _('Close Pull Request'))
             statuses = ChangesetStatus.STATUSES + [force_close]
         else:
             statuses = ChangesetStatus.STATUSES
         c.commit_statuses = statuses
 
         c.ancestor = None  # TODO: add ancestor here
         c.pull_request = pull_request_display_obj
         c.pull_request_latest = pull_request_latest
         c.at_version = at_version
 
         c.changes = None
         c.file_changes = None
 
         c.show_version_changes = 1  # control flag, not used yet
 
         if at_version and c.show_version_changes:
             c.changes, c.file_changes = self._get_pr_version_changes(
                 version, pull_request_latest)
 
         return render('/pullrequests/pullrequest_show.mako')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def comment(self, repo_name, pull_request_id):
         pull_request_id = safe_int(pull_request_id)
         pull_request = PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
 
         # TODO: johbo: Re-think this bit, "approved_closed" does not exist
         # as a changeset status, still we want to send it in one value.
         status = request.POST.get('changeset_status', None)
         text = request.POST.get('text')
         comment_type = request.POST.get('comment_type')
-        resolves_comment_id = request.POST.get('resolves_comment_id')
+        resolves_comment_id = request.POST.get('resolves_comment_id', None)
 
         if status and '_closed' in status:
             close_pr = True
             status = status.replace('_closed', '')
         else:
             close_pr = False
 
         forced = (status == 'forced')
         if forced:
             status = 'rejected'
 
         allowed_to_change_status = PullRequestModel().check_user_change_status(
             pull_request, c.rhodecode_user)
 
         if status and allowed_to_change_status:
             message = (_('Status change %(transition_icon)s %(status)s')
                        % {'transition_icon': '>',
                           'status': ChangesetStatus.get_status_lbl(status)})
             if close_pr:
                 message = _('Closing with') + ' ' + message
             text = text or message
         comm = CommentsModel().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)
                            if status and allowed_to_change_status else None),
             status_change_type=(status
                                 if status and allowed_to_change_status else None),
             closing_pr=close_pr,
             comment_type=comment_type,
             resolves_comment_id=resolves_comment_id
         )
 
         if allowed_to_change_status:
             old_calculated_status = pull_request.calculated_review_status()
             # get status if set !
             if status:
                 ChangesetStatusModel().set_status(
                     c.rhodecode_db_repo.repo_id,
                     status,
                     c.rhodecode_user.user_id,
                     comm,
                     pull_request=pull_request_id
                 )
 
             Session().flush()
             events.trigger(events.PullRequestCommentEvent(pull_request, comm))
             # we now calculate the status of pull request, and based on that
             # calculation we set the commits status
             calculated_status = pull_request.calculated_review_status()
             if old_calculated_status != calculated_status:
                 PullRequestModel()._trigger_pull_request_hook(
                     pull_request, c.rhodecode_user, 'review_status_change')
 
             calculated_status_lbl = ChangesetStatus.get_status_lbl(
                 calculated_status)
 
             if close_pr:
                 status_completed = (
                     calculated_status in [ChangesetStatus.STATUS_APPROVED,
                                           ChangesetStatus.STATUS_REJECTED])
                 if forced or status_completed:
                     PullRequestModel().close_pull_request(
                         pull_request_id, c.rhodecode_user)
                 else:
                     h.flash(_('Closing pull request on other statuses than '
                               'rejected or approved is forbidden. '
                               'Calculated status from all reviewers '
                               'is currently: %s') % calculated_status_lbl,
                             category='warning')
 
         Session().commit()
 
         if not request.is_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
             c.inline_comment = True if comm.line_no else False
             data.update(comm.get_dict())
             data.update({'rendered_text':
                              render('changeset/changeset_comment_block.mako')})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         return self._delete_comment(comment_id)
 
     def _delete_comment(self, comment_id):
         comment_id = safe_int(comment_id)
         co = ChangesetComment.get_or_404(comment_id)
         if co.pull_request.is_closed():
             # don't allow deleting comments on closed pull request
             raise HTTPForbidden()
 
         is_owner = co.author.user_id == c.rhodecode_user.user_id
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
         if h.HasPermissionAny('hg.admin')() or is_repo_admin or is_owner:
             old_calculated_status = co.pull_request.calculated_review_status()
             CommentsModel().delete(comment=co)
             Session().commit()
             calculated_status = co.pull_request.calculated_review_status()
             if old_calculated_status != calculated_status:
                 PullRequestModel()._trigger_pull_request_hook(
                     co.pull_request, c.rhodecode_user, 'review_status_change')
             return True
         else:
             raise HTTPForbidden()

rhodecode/public/css/comments.less

@@ -1,528 +1,547 b''
 // comments.less
 // For use in RhodeCode applications;
 // see style guide documentation for guidelines.
 
 
 // Comments
 .comments {
     width: 100%;
 }
 
 tr.inline-comments div {
     max-width: 100%;
 
     p {
         white-space: normal; 
     }
 
     code, pre, .code, dd {
         overflow-x: auto;
         width: 1062px;
     }
 
     dd {
         width: auto;
     }
 }
 
 #injected_page_comments {
     .comment-previous-link,
     .comment-next-link,
     .comment-links-divider {
         display: none;
     }
 }
 
 .add-comment {
     margin-bottom: 10px;
 }
 .hide-comment-button .add-comment {
     display: none;
 }
 
 .comment-bubble {
     color: @grey4;
     margin-top: 4px;
     margin-right: 30px;
     visibility: hidden;
 }
 
 .comment-label {
     float: left;
 
     padding: 0.4em 0.4em;
     margin: 2px 5px 0px -10px;
     display: inline-block;
     min-height: 0;
 
     text-align: center;
     font-size: 10px;
     line-height: .8em;
 
     font-family: @text-italic;
     background: #fff none;
     color: @grey4;
     border: 1px solid @grey4;
     white-space: nowrap;
 
     text-transform: uppercase;
     min-width: 40px;
 
     &.todo {
         color: @color5;
         font-family: @text-bold-italic;
     }
+
+    .resolve {
+        cursor: pointer;
+        text-decoration: underline;
+    }
+
+    .resolved {
+        text-decoration: line-through;
+        color: @color1;
+    }
+    .resolved a {
+        text-decoration: line-through;
+        color: @color1;
+    }
+    .resolve-text {
+        color: @color1;
+        margin: 2px 8px;
+        font-family: @text-italic;
+    }
+
 }
 
 
 .comment {
 
     &.comment-general {
         border: 1px solid @grey5;
         padding: 5px 5px 5px 5px;
     }
 
     margin: @padding 0;
     padding: 4px 0 0 0;
     line-height: 1em;
 
     .rc-user {
         min-width: 0;
         margin: 0px .5em 0 0;
 
         .user {
             display: inline;
         }
     }
 
     .meta {
         position: relative;
         width: 100%;
         border-bottom: 1px solid @grey5;
         margin: -5px 0px;
         line-height: 24px;
 
         &:hover .permalink {
             visibility: visible;
             color: @rcblue;
         }
     }
 
     .author,
     .date {
         display: inline;
 
         &:after {
             content: ' | ';
             color: @grey5;
         }
     }
 
     .author-general img {
         top: 3px;
     }
     .author-inline img {
         top: 3px;
     }
 
     .status-change,
     .permalink,
     .changeset-status-lbl {
         display: inline;
     }
 
     .permalink {
         visibility: hidden;
     }
 
     .comment-links-divider {
         display: inline;
     }
 
     .comment-links-block {
         float:right;
         text-align: right;
         min-width: 85px;
 
         [class^="icon-"]:before,
         [class*=" icon-"]:before {
             margin-left: 0;
             margin-right: 0;
         }
     }
 
     .comment-previous-link {
         display: inline-block;
 
         .arrow_comment_link{
             cursor: pointer;
             i {
                 font-size:10px;
             }
         }
         .arrow_comment_link.disabled {
             cursor: default;
             color: @grey5;
         }
     }
 
     .comment-next-link {
         display: inline-block;
 
         .arrow_comment_link{
             cursor: pointer;
             i {
                 font-size:10px;
             }
         }
         .arrow_comment_link.disabled {
             cursor: default;
             color: @grey5;
         }
     }
 
     .flag_status {
         display: inline-block;
         margin: -2px .5em 0 .25em
     }
 
     .delete-comment {
         display: inline-block;
         color: @rcblue;
         
         &:hover {
             cursor: pointer;
         }
     }
 
-
     .text {
         clear: both;
         .border-radius(@border-radius);
         .box-sizing(border-box);
 
         .markdown-block p,
         .rst-block p {
             margin: .5em 0 !important;
           // TODO: lisa: This is needed because of other rst !important rules :[
         }
     }
 
     .pr-version {
         float: left;
         margin: 0px 4px;
     }
     .pr-version-inline {
         float: left;
         margin: 0px 4px;
     }
     .pr-version-num {
         font-size: 10px;
     }
 
 }
 
 @comment-padding: 5px;
 
 .inline-comments {
     border-radius: @border-radius;
     .comment {
         margin: 0;
         border-radius: @border-radius;
     }
     .comment-outdated {
         opacity: 0.5;
     }
 
     .comment-inline {
         background: white;
         padding: @comment-padding @comment-padding;
         border: @comment-padding solid @grey6;
 
         .text {
             border: none;
         }
         .meta {
             border-bottom: 1px solid @grey6;
             margin: -5px 0px;
             line-height: 24px;
         }
     }
     .comment-selected {
         border-left: 6px solid @comment-highlight-color;
     }
     .comment-inline-form {
         padding: @comment-padding;
         display: none;
     }
     .cb-comment-add-button {
         margin: @comment-padding;
     }
      /* hide add comment button when form is open */
     .comment-inline-form-open ~ .cb-comment-add-button {
         display: none;
     }
     .comment-inline-form-open {
         display: block;
     }
      /* hide add comment button when form but no comments */
     .comment-inline-form:first-child + .cb-comment-add-button {
         display: none;
     }
      /* hide add comment button when no comments or form */
     .cb-comment-add-button:first-child {
         display: none;
     }
      /* hide add comment button when only comment is being deleted */
     .comment-deleting:first-child + .cb-comment-add-button {
         display: none;
     }
 }
 
 
 .show-outdated-comments {
     display: inline;
     color: @rcblue;
 }
 
 // Comment Form
 div.comment-form {
     margin-top: 20px;
 }
 
 .comment-form strong {
     display: block;
     margin-bottom: 15px;
 }
 
 .comment-form textarea {
     width: 100%;
     height: 100px;
     font-family: 'Monaco', 'Courier', 'Courier New', monospace;
 }
 
 form.comment-form {
     margin-top: 10px;
     margin-left: 10px;
 }
 
 .comment-inline-form .comment-block-ta,
 .comment-form .comment-block-ta,
 .comment-form .preview-box {
     .border-radius(@border-radius);
     .box-sizing(border-box);
     background-color: white;
 }
 
 .comment-form-submit {
     margin-top: 5px;
     margin-left: 525px;
 }
 
 .file-comments {
     display: none;
 }
 
 .comment-form .preview-box.unloaded,
 .comment-inline-form .preview-box.unloaded {
     height: 50px;
     text-align: center;
     padding: 20px;
     background-color: white;
 }
 
 .comment-footer {
     position: relative;
     width: 100%;
     min-height: 42px;
     
     .status_box,
     .cancel-button {
         float: left;
         display: inline-block;
     }
     
     .action-buttons {
         float: right;
         display: inline-block;
     }
 }
 
 .comment-form {
 
     .comment {
         margin-left: 10px;
     }
 
     .comment-help {
         color: @grey4;
         padding: 5px 0 5px 0;
     }
 
     .comment-title {
         padding: 5px 0 5px 0;
     }
 
     .comment-button {
         display: inline-block;
     }
 
     .comment-button-input {
         margin-right: 0;
     }
 
     .comment-footer {
         margin-bottom: 110px;
         margin-top: 10px;
     }
 }
 
 
 .comment-form-login {
     .comment-help {
         padding: 0.9em; //same as the button
     }
 
     div.clearfix { 
         clear: both;
         width: 100%;
         display: block;
     }
 }
 
 .comment-type {
     margin: 0px;
     border-radius: inherit;
     border-color: @grey6;
 }
 
 .preview-box {
     min-height: 105px;
     margin-bottom: 15px;
     background-color: white;
     .border-radius(@border-radius);
     .box-sizing(border-box);
 }
 
 .add-another-button {
     margin-left: 10px;
     margin-top: 10px;
     margin-bottom: 10px;
 }
 
 .comment .buttons {
     float: right;
     margin: -1px 0px 0px 0px;
 }
 
 // Inline Comment Form
 .injected_diff .comment-inline-form,
 .comment-inline-form {
     background-color: white;
     margin-top: 10px;
     margin-bottom: 20px;
 }
 
 .inline-form {
     padding: 10px 7px;
 }
 
 .inline-form div {
     max-width: 100%;
 }
 
 .overlay {
     display: none;
     position: absolute;
     width: 100%;
     text-align: center;
     vertical-align: middle;
     font-size: 16px;
     background: none repeat scroll 0 0 white;
 
     &.submitting {
         display: block;
         opacity: 0.5;
         z-index: 100;
     }
 }
 .comment-inline-form .overlay.submitting .overlay-text {
     margin-top: 5%;
 }
 
 .comment-inline-form .clearfix,
 .comment-form .clearfix {
     .border-radius(@border-radius);
     margin: 0px;
 }
 
 .comment-inline-form .comment-footer {
     margin: 10px 0px 0px 0px;
 }
 
 .hide-inline-form-button {
     margin-left: 5px;
 }
 .comment-button .hide-inline-form {
     background: white;
 }
 
 .comment-area {
     padding: 8px 12px;
     border: 1px solid @grey5;
     .border-radius(@border-radius);
 }
 
 .comment-area-header .nav-links {
     display: flex;
     flex-flow: row wrap;
     -webkit-flex-flow: row wrap;
     width: 100%;
 }
 
 .comment-area-footer {
     display: flex;
 }
 
 .comment-footer .toolbar {
 
 }
 
 .nav-links {
     padding: 0;
     margin: 0;
     list-style: none;
     height: auto;
     border-bottom: 1px solid @grey5;
 }
 .nav-links li {
     display: inline-block;
 }
 .nav-links li:before {
     content: "";
 }
 .nav-links li a.disabled {
     cursor: not-allowed;
 }
 
 .nav-links li.active a {
     border-bottom: 2px solid @rcblue;
     color: #000;
     font-weight: 600;
 }
 .nav-links li a {
     display: inline-block;
     padding: 0px 10px 5px 10px;
     margin-bottom: -1px;
     font-size: 14px;
     line-height: 28px;
     color: #8f8f8f;
     border-bottom: 2px solid transparent;
 }
 
 .toolbar-text {
     float: left;
     margin: -5px 0px 0px 0px;
     font-size: 12px;
 }
 

rhodecode/public/js/src/rhodecode/codemirror.js

@@ -1,530 +1,530 b''
 // # Copyright (C) 2010-2017 RhodeCode GmbH
 // #
 // # This program is free software: you can redistribute it and/or modify
 // # it under the terms of the GNU Affero General Public License, version 3
 // # (only), as published by the Free Software Foundation.
 // #
 // # 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 Affero General Public License
 // # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #
 // # This program is dual-licensed. If you wish to learn more about the
 // # RhodeCode Enterprise Edition, including its added features, Support services,
 // # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 /**
  * Code Mirror
  */
 // global code-mirror logger;, to enable run
 // Logger.get('CodeMirror').setLevel(Logger.DEBUG)
 
 cmLog = Logger.get('CodeMirror');
 cmLog.setLevel(Logger.OFF);
 
 
 //global cache for inline forms
 var userHintsCache = {};
 
 // global timer, used to cancel async loading
 var CodeMirrorLoadUserHintTimer;
 
 var escapeRegExChars = function(value) {
   return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
 };
 
 /**
  * Load hints from external source returns an array of objects in a format
  * that hinting lib requires
  * @returns {Array}
  */
 var CodeMirrorLoadUserHints = function(query, triggerHints) {
   cmLog.debug('Loading mentions users via AJAX');
   var _users = [];
   $.ajax({
     type: 'GET',
     data: {query: query},
     url: pyroutes.url('user_autocomplete_data'),
     headers: {'X-PARTIAL-XHR': true},
     async: true
   })
   .done(function(data) {
     var tmpl = '<img class="gravatar" src="{0}"/>{1}';
     $.each(data.suggestions, function(i) {
       var userObj = data.suggestions[i];
 
       if (userObj.username !== "default") {
         _users.push({
           text: userObj.username + " ",
           org_text: userObj.username,
           displayText: userObj.value_display, // search that field
           // internal caches
           _icon_link: userObj.icon_link,
           _text: userObj.value_display,
 
           render: function(elt, data, completion) {
             var el = document.createElement('div');
             el.className = "CodeMirror-hint-entry";
             el.innerHTML = tmpl.format(
                 completion._icon_link, completion._text);
             elt.appendChild(el);
           }
         });
       }
     });
     cmLog.debug('Mention users loaded');
     // set to global cache
     userHintsCache[query] = _users;
     triggerHints(userHintsCache[query]);
   })
   .fail(function(data, textStatus, xhr) {
     alert("error processing request: " + textStatus);
   });
 };
 
 /**
  * filters the results based on the current context
  * @param users
  * @param context
  * @returns {Array}
  */
 var CodeMirrorFilterUsers = function(users, context) {
   var MAX_LIMIT = 10;
   var filtered_users = [];
   var curWord = context.string;
 
   cmLog.debug('Filtering users based on query:', curWord);
   $.each(users, function(i) {
     var match = users[i];
     var searchText = match.displayText;
 
     if (!curWord ||
         searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
       // reset state
       match._text = match.displayText;
       if (curWord) {
         // do highlighting
         var pattern = '(' + escapeRegExChars(curWord) + ')';
         match._text = searchText.replace(
             new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
       }
 
       filtered_users.push(match);
     }
     // to not return to many results, use limit of filtered results
     if (filtered_users.length > MAX_LIMIT) {
       return false;
     }
   });
 
   return filtered_users;
 };
 
 var CodeMirrorMentionHint = function(editor, callback, options) {
   var cur = editor.getCursor();
   var curLine = editor.getLine(cur.line).slice(0, cur.ch);
 
   // match on @ +1char
   var tokenMatch = new RegExp(
       '(^@| @)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]*)$').exec(curLine);
 
   var tokenStr = '';
   if (tokenMatch !== null && tokenMatch.length > 0){
     tokenStr = tokenMatch[0].strip();
   } else {
     // skip if we didn't match our token
     return;
   }
 
   var context = {
     start: (cur.ch - tokenStr.length) + 1,
     end: cur.ch,
     string: tokenStr.slice(1),
     type: null
   };
 
   // case when we put the @sign in fron of a string,
   // eg <@ we put it here>sometext then we need to prepend to text
   if (context.end > cur.ch) {
     context.start = context.start + 1; // we add to the @ sign
     context.end = cur.ch; // don't eat front part just append
     context.string = context.string.slice(1, cur.ch - context.start);
   }
 
   cmLog.debug('Mention context', context);
 
   var triggerHints = function(userHints){
     return callback({
       list: CodeMirrorFilterUsers(userHints, context),
       from: CodeMirror.Pos(cur.line, context.start),
       to: CodeMirror.Pos(cur.line, context.end)
     });
   };
 
   var queryBasedHintsCache = undefined;
   // if we have something in the cache, try to fetch the query based cache
   if (userHintsCache !== {}){
     queryBasedHintsCache = userHintsCache[context.string];
   }
 
   if (queryBasedHintsCache !== undefined) {
     cmLog.debug('Users loaded from cache');
     triggerHints(queryBasedHintsCache);
   } else {
     // this takes care for async loading, and then displaying results
     // and also propagates the userHintsCache
     window.clearTimeout(CodeMirrorLoadUserHintTimer);
     CodeMirrorLoadUserHintTimer = setTimeout(function() {
       CodeMirrorLoadUserHints(context.string, triggerHints);
     }, 300);
   }
 };
 
 var CodeMirrorCompleteAfter = function(cm, pred) {
   var options = {
     completeSingle: false,
     async: true,
     closeOnUnfocus: true
   };
   var cur = cm.getCursor();
   setTimeout(function() {
     if (!cm.state.completionActive) {
       cmLog.debug('Trigger mentions hinting');
       CodeMirror.showHint(cm, CodeMirror.hint.mentions, options);
     }
   }, 100);
 
   // tell CodeMirror we didn't handle the key
   // trick to trigger on a char but still complete it
   return CodeMirror.Pass;
 };
 
 var initCodeMirror = function(textAreadId, resetUrl, focus, options) {
   var ta = $('#' + textAreadId).get(0);
   if (focus === undefined) {
       focus = true;
   }
 
   // default options
   var codeMirrorOptions = {
     mode: "null",
     lineNumbers: true,
     indentUnit: 4,
     autofocus: focus
   };
 
   if (options !== undefined) {
     // extend with custom options
     codeMirrorOptions = $.extend(true, codeMirrorOptions, options);
   }
 
   var myCodeMirror = CodeMirror.fromTextArea(ta, codeMirrorOptions);
 
   $('#reset').on('click', function(e) {
     window.location = resetUrl;
   });
 
   return myCodeMirror;
 };
 
 var initCommentBoxCodeMirror = function(textAreaId, triggerActions){
   var initialHeight = 100;
 
   if (typeof userHintsCache === "undefined") {
     userHintsCache = {};
     cmLog.debug('Init empty cache for mentions');
   }
   if (!$(textAreaId).get(0)) {
     cmLog.debug('Element for textarea not found', textAreaId);
     return;
   }
     /**
      * Filter action based on typed in text
      * @param actions
      * @param context
      * @returns {Array}
      */
 
     var filterActions = function(actions, context){
       var MAX_LIMIT = 10;
       var filtered_actions= [];
       var curWord = context.string;
 
       cmLog.debug('Filtering actions based on query:', curWord);
       $.each(actions, function(i) {
         var match = actions[i];
         var searchText = match.displayText;
 
         if (!curWord ||
           searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
           // reset state
           match._text = match.displayText;
           if (curWord) {
             // do highlighting
             var pattern = '(' + escapeRegExChars(curWord) + ')';
             match._text = searchText.replace(
               new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
           }
 
           filtered_actions.push(match);
         }
         // to not return to many results, use limit of filtered results
         if (filtered_actions.length > MAX_LIMIT) {
             return false;
         }
       });
       return filtered_actions;
     };
 
     var submitForm = function(cm, pred) {
       $(cm.display.input.textarea.form).submit();
       return CodeMirror.Pass;
     };
 
     var completeActions = function(cm, pred) {
       var cur = cm.getCursor();
       var options = {
         closeOnUnfocus: true
       };
       setTimeout(function() {
         if (!cm.state.completionActive) {
           cmLog.debug('Trigger actions hinting');
           CodeMirror.showHint(cm, CodeMirror.hint.actions, options);
         }
       }, 100);
     };
 
     var extraKeys = {
       "'@'": CodeMirrorCompleteAfter,
       Tab: function(cm) {
         // space indent instead of TABS
         var spaces = new Array(cm.getOption("indentUnit") + 1).join(" ");
         cm.replaceSelection(spaces);
       }
     };
     // submit form on Meta-Enter
     if (OSType === "mac") {
       extraKeys["Cmd-Enter"] = submitForm;
     }
     else {
       extraKeys["Ctrl-Enter"] = submitForm;
     }
 
     if (triggerActions) {
       extraKeys["Ctrl-Space"] = completeActions;
     }
 
     var cm = CodeMirror.fromTextArea($(textAreaId).get(0), {
       lineNumbers: false,
       indentUnit: 4,
       viewportMargin: 30,
       // this is a trick to trigger some logic behind codemirror placeholder
       // it influences styling and behaviour.
       placeholder: " ",
       extraKeys: extraKeys,
       lineWrapping: true
     });
 
     cm.setSize(null, initialHeight);
     cm.setOption("mode", DEFAULT_RENDERER);
     CodeMirror.autoLoadMode(cm, DEFAULT_RENDERER); // load rst or markdown mode
     cmLog.debug('Loading codemirror mode', DEFAULT_RENDERER);
     // start listening on changes to make auto-expanded editor
     cm.on("change", function(self) {
       var height = initialHeight;
       var lines = self.lineCount();
       if ( lines > 6 && lines < 20) {
         height = "auto";
       }
       else if (lines >= 20){
         zheight = 20*15;
       }
       self.setSize(null, height);
     });
 
     var actionHint = function(editor, options) {
       var cur = editor.getCursor();
       var curLine = editor.getLine(cur.line).slice(0, cur.ch);
 
       var tokenMatch = new RegExp('[a-zA-Z]{1}[a-zA-Z]*$').exec(curLine);
 
       var tokenStr = '';
       if (tokenMatch !== null && tokenMatch.length > 0){
         tokenStr = tokenMatch[0].strip();
       }
 
       var context = {
         start: cur.ch - tokenStr.length,
         end: cur.ch,
         string: tokenStr,
         type: null
       };
 
       var actions = [
         {
           text: "approve",
           displayText: _gettext('Set status to Approved'),
           hint: function(CodeMirror, data, completion) {
             CodeMirror.replaceRange("", completion.from || data.from,
                         completion.to || data.to, "complete");
-            $('#change_status').select2("val", 'approved').trigger('change');
+            $('#change_status_general').select2("val", 'approved').trigger('change');
           },
           render: function(elt, data, completion) {
             var el = document.createElement('div');
             el.className = "flag_status flag_status_comment_box approved pull-left";
             elt.appendChild(el);
 
             el = document.createElement('span');
             el.innerHTML = completion.displayText;
             elt.appendChild(el);
           }
         },
         {
           text: "reject",
           displayText: _gettext('Set status to Rejected'),
           hint: function(CodeMirror, data, completion) {
               CodeMirror.replaceRange("", completion.from || data.from,
                           completion.to || data.to, "complete");
-              $('#change_status').select2("val", 'rejected').trigger('change');
+              $('#change_status_general').select2("val", 'rejected').trigger('change');
           },
           render: function(elt, data, completion) {
               var el = document.createElement('div');
               el.className = "flag_status flag_status_comment_box rejected pull-left";
               elt.appendChild(el);
 
               el = document.createElement('span');
               el.innerHTML = completion.displayText;
               elt.appendChild(el);
           }
         }
       ];
 
       return {
         list: filterActions(actions, context),
         from: CodeMirror.Pos(cur.line, context.start),
         to: CodeMirror.Pos(cur.line, context.end)
       };
     };
     CodeMirror.registerHelper("hint", "mentions", CodeMirrorMentionHint);
     CodeMirror.registerHelper("hint", "actions", actionHint);
     return cm;
 };
 
 var setCodeMirrorMode = function(codeMirrorInstance, mode) {
   CodeMirror.autoLoadMode(codeMirrorInstance, mode);
   codeMirrorInstance.setOption("mode", mode);
 };
 
 var setCodeMirrorLineWrap = function(codeMirrorInstance, line_wrap) {
   codeMirrorInstance.setOption("lineWrapping", line_wrap);
 };
 
 var setCodeMirrorModeFromSelect = function(
   targetSelect, targetFileInput, codeMirrorInstance, callback){
 
   $(targetSelect).on('change', function(e) {
     cmLog.debug('codemirror select2 mode change event !');
     var selected = e.currentTarget;
     var node = selected.options[selected.selectedIndex];
     var mimetype = node.value;
     cmLog.debug('picked mimetype', mimetype);
     var new_mode = $(node).attr('mode');
     setCodeMirrorMode(codeMirrorInstance, new_mode);
     cmLog.debug('set new mode', new_mode);
 
     //propose filename from picked mode
     cmLog.debug('setting mimetype', mimetype);
     var proposed_ext = getExtFromMimeType(mimetype);
     cmLog.debug('file input', $(targetFileInput).val());
     var file_data = getFilenameAndExt($(targetFileInput).val());
     var filename = file_data.filename || 'filename1';
     $(targetFileInput).val(filename + proposed_ext);
     cmLog.debug('proposed file', filename + proposed_ext);
 
 
     if (typeof(callback) === 'function') {
       try {
         cmLog.debug('running callback', callback);
         callback(filename, mimetype, new_mode);
       } catch (err) {
         console.log('failed to run callback', callback, err);
       }
     }
     cmLog.debug('finish iteration...');
   });
 };
 
 var setCodeMirrorModeFromInput = function(
   targetSelect, targetFileInput, codeMirrorInstance, callback) {
 
   // on type the new filename set mode
   $(targetFileInput).on('keyup', function(e) {
     var file_data = getFilenameAndExt(this.value);
     if (file_data.ext === null) {
       return;
     }
 
     var mimetypes = getMimeTypeFromExt(file_data.ext, true);
     cmLog.debug('mimetype from file', file_data, mimetypes);
     var detected_mode;
     var detected_option;
     for (var i in mimetypes) {
       var mt = mimetypes[i];
       if (!detected_mode) {
         detected_mode = detectCodeMirrorMode(this.value, mt);
       }
 
       if (!detected_option) {
         cmLog.debug('#mimetype option[value="{0}"]'.format(mt));
         if ($(targetSelect).find('option[value="{0}"]'.format(mt)).length) {
           detected_option = mt;
         }
       }
     }
 
     cmLog.debug('detected mode', detected_mode);
     cmLog.debug('detected option', detected_option);
     if (detected_mode && detected_option){
 
       $(targetSelect).select2("val", detected_option);
       setCodeMirrorMode(codeMirrorInstance, detected_mode);
 
       if(typeof(callback) === 'function'){
         try{
           cmLog.debug('running callback', callback);
           var filename = file_data.filename + "." + file_data.ext;
           callback(filename, detected_option, detected_mode);
         }catch (err){
           console.log('failed to run callback', callback, err);
         }
       }
     }
 
   });
 };
 
 var fillCodeMirrorOptions = function(targetSelect) {
   //inject new modes, based on codeMirrors modeInfo object
   var modes_select = $(targetSelect);
   for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
     var m = CodeMirror.modeInfo[i];
     var opt = new Option(m.name, m.mime);
     $(opt).attr('mode', m.mode);
     modes_select.append(opt);
   }
 };
 
 var CodeMirrorPreviewEnable = function(edit_mode) {
   // in case it a preview enabled mode enable the button
   if (['markdown', 'rst', 'gfm'].indexOf(edit_mode) !== -1) {
     $('#render_preview').removeClass('hidden');
   }
   else {
     if (!$('#render_preview').hasClass('hidden')) {
       $('#render_preview').addClass('hidden');
     }
   }
 };

rhodecode/public/js/src/rhodecode/comments.js

@@ -1,798 +1,842 b''
 // # Copyright (C) 2010-2017 RhodeCode GmbH
 // #
 // # This program is free software: you can redistribute it and/or modify
 // # it under the terms of the GNU Affero General Public License, version 3
 // # (only), as published by the Free Software Foundation.
 // #
 // # 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 Affero General Public License
 // # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #
 // # This program is dual-licensed. If you wish to learn more about the
 // # RhodeCode Enterprise Edition, including its added features, Support services,
 // # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 var firefoxAnchorFix = function() {
   // hack to make anchor links behave properly on firefox, in our inline
   // comments generation when comments are injected firefox is misbehaving
   // when jumping to anchor links
   if (location.href.indexOf('#') > -1) {
     location.href += '';
   }
 };
 
 // returns a node from given html;
 var fromHTML = function(html){
   var _html = document.createElement('element');
   _html.innerHTML = html;
   return _html;
 };
 
 var tableTr = function(cls, body){
   var _el = document.createElement('div');
   var _body = $(body).attr('id');
   var comment_id = fromHTML(body).children[0].id.split('comment-')[1];
   var id = 'comment-tr-{0}'.format(comment_id);
   var _html = ('<table><tbody><tr id="{0}" class="{1}">'+
                '<td class="add-comment-line tooltip tooltip" title="Add Comment"><span class="add-comment-content"></span></td>'+
                '<td></td>'+
                '<td></td>'+
                '<td></td>'+
                '<td>{2}</td>'+
                '</tr></tbody></table>').format(id, cls, body);
   $(_el).html(_html);
   return _el.children[0].children[0].children[0];
 };
 
 function bindDeleteCommentButtons() {
     $('.delete-comment').one('click', function() {
         var comment_id = $(this).data("comment-id");
 
         if (comment_id){
             deleteComment(comment_id);
         }
     });
 }
 
 var deleteComment = function(comment_id) {
   var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id);
   var postData = {
     '_method': 'delete',
     'csrf_token': CSRF_TOKEN
   };
 
   var success = function(o) {
     window.location.reload();
   };
   ajaxPOST(url, postData, success);
 };
 
 
 var bindToggleButtons = function() {
   $('.comment-toggle').on('click', function() {
         $(this).parent().nextUntil('tr.line').toggle('inline-comments');
   });
 };
 
 var linkifyComments = function(comments) {
   /* TODO: marcink: remove this - it should no longer needed */
   for (var i = 0; i < comments.length; i++) {
     var comment_id = $(comments[i]).data('comment-id');
     var prev_comment_id = $(comments[i - 1]).data('comment-id');
     var next_comment_id = $(comments[i + 1]).data('comment-id');
 
     // place next/prev links
     if (prev_comment_id) {
       $('#prev_c_' + comment_id).show();
       $('#prev_c_' + comment_id + " a.arrow_comment_link").attr(
           'href', '#comment-' + prev_comment_id).removeClass('disabled');
     }
     if (next_comment_id) {
       $('#next_c_' + comment_id).show();
       $('#next_c_' + comment_id + " a.arrow_comment_link").attr(
           'href', '#comment-' + next_comment_id).removeClass('disabled');
     }
     /* TODO(marcink): end removal here */
 
     // place a first link to the total counter
     if (i === 0) {
       $('#inline-comments-counter').attr('href', '#comment-' + comment_id);
     }
   }
 
 };
 
+var bindToggleButtons = function() {
+  $('.comment-toggle').on('click', function() {
+        $(this).parent().nextUntil('tr.line').toggle('inline-comments');
+  });
+};
 
 /* Comment form for main and inline comments */
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     module.exports = mod();
   else // Plain browser env
     (this || window).CommentForm = mod();
 
 })(function() {
     "use strict";
 
     function CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId) {
         if (!(this instanceof CommentForm)) {
             return new CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId);
         }
 
         // bind the element instance to our Form
         $(formElement).get(0).CommentForm = this;
 
         this.withLineNo = function(selector) {
             var lineNo = this.lineNo;
             if (lineNo === undefined) {
                 return selector
             } else {
                 return selector + '_' + lineNo;
             }
         };
 
         this.commitId = commitId;
         this.pullRequestId = pullRequestId;
         this.lineNo = lineNo;
         this.initAutocompleteActions = initAutocompleteActions;
 
         this.previewButton = this.withLineNo('#preview-btn');
         this.previewContainer = this.withLineNo('#preview-container');
 
         this.previewBoxSelector = this.withLineNo('#preview-box');
 
         this.editButton = this.withLineNo('#edit-btn');
         this.editContainer = this.withLineNo('#edit-container');
         this.cancelButton = this.withLineNo('#cancel-btn');
         this.commentType = this.withLineNo('#comment_type');
 
         this.resolvesId = null;
         this.resolvesActionId = null;
 
         this.cmBox = this.withLineNo('#text');
         this.cm = initCommentBoxCodeMirror(this.cmBox, this.initAutocompleteActions);
 
-        this.statusChange = '#change_status';
+        this.statusChange = this.withLineNo('#change_status');
 
         this.submitForm = formElement;
         this.submitButton = $(this.submitForm).find('input[type="submit"]');
         this.submitButtonText = this.submitButton.val();
 
         this.previewUrl = pyroutes.url('changeset_comment_preview',
             {'repo_name': templateContext.repo_name});
 
         if (resolvesCommentId){
             this.resolvesId = '#resolve_comment_{0}'.format(resolvesCommentId);
             this.resolvesActionId = '#resolve_comment_action_{0}'.format(resolvesCommentId);
             $(this.commentType).prop('disabled', true);
             $(this.commentType).addClass('disabled');
 
+            // disable select
+            setTimeout(function() {
+                $(self.statusChange).select2('readonly', true);
+            }, 10);
+
+
             var resolvedInfo = (
                 '<li class="">' +
                 '<input type="hidden" id="resolve_comment_{0}" name="resolve_comment_{0}" value="{0}">' +
                 '<button id="resolve_comment_action_{0}" class="resolve-text btn btn-sm" onclick="return Rhodecode.comments.submitResolution({0})">{1} #{0}</button>' +
                 '</li>'
             ).format(resolvesCommentId, _gettext('resolve comment'));
             $(resolvedInfo).insertAfter($(this.commentType).parent());
         }
 
         // based on commitId, or pullRequestId decide where do we submit
         // out data
         if (this.commitId){
             this.submitUrl = pyroutes.url('changeset_comment',
                 {'repo_name': templateContext.repo_name,
                  'revision': this.commitId});
             this.selfUrl = pyroutes.url('changeset_home',
                 {'repo_name': templateContext.repo_name,
                  'revision': this.commitId});
 
         } else if (this.pullRequestId) {
             this.submitUrl = pyroutes.url('pullrequest_comment',
                 {'repo_name': templateContext.repo_name,
                  'pull_request_id': this.pullRequestId});
             this.selfUrl = pyroutes.url('pullrequest_show',
                 {'repo_name': templateContext.repo_name,
                  'pull_request_id': this.pullRequestId});
 
         } else {
             throw new Error(
                 'CommentForm requires pullRequestId, or commitId to be specified.')
         }
 
+        // FUNCTIONS and helpers
+        var self = this;
+
+        this.isInline = function(){
+            return this.lineNo && this.lineNo != 'general';
+        };
+
         this.getCmInstance = function(){
             return this.cm
         };
 
         this.setPlaceholder = function(placeholder) {
             var cm = this.getCmInstance();
             if (cm){
                 cm.setOption('placeholder', placeholder);
             }
         };
 
-        var self = this;
-
         this.getCommentStatus = function() {
           return $(this.submitForm).find(this.statusChange).val();
         };
         this.getCommentType = function() {
           return $(this.submitForm).find(this.commentType).val();
         };
 
         this.getResolvesId = function() {
             return $(this.submitForm).find(this.resolvesId).val() || null;
         };
         this.markCommentResolved = function(resolvedCommentId){
             $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolved').show();
             $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolve').hide();
         };
 
         this.isAllowedToSubmit = function() {
           return !$(this.submitButton).prop('disabled');
         };
 
         this.initStatusChangeSelector = function(){
             var formatChangeStatus = function(state, escapeMarkup) {
                 var originalOption = state.element;
                 return '<div class="flag_status ' + $(originalOption).data('status') + ' pull-left"></div>' +
                        '<span>' + escapeMarkup(state.text) + '</span>';
             };
             var formatResult = function(result, container, query, escapeMarkup) {
                 return formatChangeStatus(result, escapeMarkup);
             };
 
             var formatSelection = function(data, container, escapeMarkup) {
                 return formatChangeStatus(data, escapeMarkup);
             };
 
             $(this.submitForm).find(this.statusChange).select2({
                 placeholder: _gettext('Status Review'),
                 formatResult: formatResult,
                 formatSelection: formatSelection,
                 containerCssClass: "drop-menu status_box_menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 dropdownAutoWidth: true,
                 minimumResultsForSearch: -1
             });
             $(this.submitForm).find(this.statusChange).on('change', function() {
                 var status = self.getCommentStatus();
-                if (status && self.lineNo == 'general') {
+                if (status && !self.isInline()) {
                     $(self.submitButton).prop('disabled', false);
                 }
 
                 var placeholderText = _gettext('Comment text will be set automatically based on currently selected status ({0}) ...').format(status);
                 self.setPlaceholder(placeholderText)
             })
         };
 
         // reset the comment form into it's original state
         this.resetCommentFormState = function(content) {
             content = content || '';
 
             $(this.editContainer).show();
             $(this.editButton).parent().addClass('active');
 
             $(this.previewContainer).hide();
             $(this.previewButton).parent().removeClass('active');
 
             this.setActionButtonsDisabled(true);
             self.cm.setValue(content);
             self.cm.setOption("readOnly", false);
         };
 
         this.submitAjaxPOST = function(url, postData, successHandler, failHandler) {
             failHandler = failHandler || function() {};
             var postData = toQueryString(postData);
             var request = $.ajax({
                     url: url,
                     type: 'POST',
                     data: postData,
                     headers: {'X-PARTIAL-XHR': true}
                 })
                 .done(function(data) {
                     successHandler(data);
                 })
                 .fail(function(data, textStatus, errorThrown){
                     alert(
                         "Error while submitting comment.\n" +
                         "Error code {0} ({1}).".format(data.status, data.statusText));
                     failHandler()
                 });
             return request;
         };
 
         // overwrite a submitHandler, we need to do it for inline comments
         this.setHandleFormSubmit = function(callback) {
             this.handleFormSubmit = callback;
         };
 
         // default handler for for submit for main comments
         this.handleFormSubmit = function() {
             var text = self.cm.getValue();
             var status = self.getCommentStatus();
             var commentType = self.getCommentType();
             var resolvesCommentId = self.getResolvesId();
 
             if (text === "" && !status) {
                 return;
             }
 
             var excludeCancelBtn = false;
             var submitEvent = true;
             self.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
             self.cm.setOption("readOnly", true);
+
             var postData = {
                 'text': text,
                 'changeset_status': status,
                 'comment_type': commentType,
                 'csrf_token': CSRF_TOKEN
             };
             if (resolvesCommentId){
                 postData['resolves_comment_id'] = resolvesCommentId;
             }
             var submitSuccessCallback = function(o) {
                 if (status) {
                     location.reload(true);
                 } else {
                     $('#injected_page_comments').append(o.rendered_text);
                     self.resetCommentFormState();
                     bindDeleteCommentButtons();
                     timeagoActivate();
 
-                    //mark visually which comment was resolved
+                    // mark visually which comment was resolved
                     if (resolvesCommentId) {
-                        this.markCommentResolved(resolvesCommentId);
+                        self.markCommentResolved(resolvesCommentId);
                     }
                 }
             };
             var submitFailCallback = function(){
                 self.resetCommentFormState(text);
             };
             self.submitAjaxPOST(
                 self.submitUrl, postData, submitSuccessCallback, submitFailCallback);
         };
 
         this.previewSuccessCallback = function(o) {
             $(self.previewBoxSelector).html(o);
             $(self.previewBoxSelector).removeClass('unloaded');
 
             // swap buttons, making preview active
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
 
             // unlock buttons
             self.setActionButtonsDisabled(false);
         };
 
         this.setActionButtonsDisabled = function(state, excludeCancelBtn, submitEvent) {
             excludeCancelBtn = excludeCancelBtn || false;
             submitEvent = submitEvent || false;
 
             $(this.editButton).prop('disabled', state);
             $(this.previewButton).prop('disabled', state);
 
             if (!excludeCancelBtn) {
                 $(this.cancelButton).prop('disabled', state);
             }
 
             var submitState = state;
             if (!submitEvent && this.getCommentStatus() && !this.lineNo) {
                 // if the value of commit review status is set, we allow
                 // submit button, but only on Main form, lineNo means inline
                 submitState = false
             }
             $(this.submitButton).prop('disabled', submitState);
             if (submitEvent) {
               $(this.submitButton).val(_gettext('Submitting...'));
             } else {
               $(this.submitButton).val(this.submitButtonText);
             }
 
         };
 
         // lock preview/edit/submit buttons on load, but exclude cancel button
         var excludeCancelBtn = true;
         this.setActionButtonsDisabled(true, excludeCancelBtn);
 
         // anonymous users don't have access to initialized CM instance
         if (this.cm !== undefined){
             this.cm.on('change', function(cMirror) {
                 if (cMirror.getValue() === "") {
                     self.setActionButtonsDisabled(true, excludeCancelBtn)
                 } else {
                     self.setActionButtonsDisabled(false, excludeCancelBtn)
                 }
             });
         }
 
         $(this.editButton).on('click', function(e) {
             e.preventDefault();
 
             $(self.previewButton).parent().removeClass('active');
             $(self.previewContainer).hide();
 
             $(self.editButton).parent().addClass('active');
             $(self.editContainer).show();
 
         });
 
         $(this.previewButton).on('click', function(e) {
             e.preventDefault();
             var text = self.cm.getValue();
 
             if (text === "") {
                 return;
             }
 
             var postData = {
                 'text': text,
                 'renderer': templateContext.visual.default_renderer,
                 'csrf_token': CSRF_TOKEN
             };
 
             // lock ALL buttons on preview
             self.setActionButtonsDisabled(true);
 
             $(self.previewBoxSelector).addClass('unloaded');
             $(self.previewBoxSelector).html(_gettext('Loading ...'));
 
             $(self.editContainer).hide();
             $(self.previewContainer).show();
 
             // by default we reset state of comment preserving the text
             var previewFailCallback = function(){
                 self.resetCommentFormState(text)
             };
             self.submitAjaxPOST(
                 self.previewUrl, postData, self.previewSuccessCallback,
                 previewFailCallback);
 
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
         });
 
         $(this.submitForm).submit(function(e) {
             e.preventDefault();
             var allowedToSubmit = self.isAllowedToSubmit();
             if (!allowedToSubmit){
                return false;
             }
             self.handleFormSubmit();
         });
 
     }
 
     return CommentForm;
 });
 
 /* comments controller */
 var CommentsController = function() {
   var mainComment = '#text';
   var self = this;
 
   this.cancelComment = function(node) {
       var $node = $(node);
       var $td = $node.closest('td');
       $node.closest('.comment-inline-form').remove();
       return false;
   };
 
   this.getLineNumber = function(node) {
       var $node = $(node);
       return $node.closest('td').attr('data-line-number');
   };
 
   this.scrollToComment = function(node, offset, outdated) {
     var outdated = outdated || false;
     var klass = outdated ? 'div.comment-outdated' : 'div.comment-current';
 
     if (!node) {
       node = $('.comment-selected');
       if (!node.length) {
         node = $('comment-current')
       }
     }
     $comment = $(node).closest(klass);
     $comments = $(klass);
 
     $('.comment-selected').removeClass('comment-selected');
 
     var nextIdx = $(klass).index($comment) + offset;
     if (nextIdx >= $comments.length) {
       nextIdx = 0;
     }
     var $next = $(klass).eq(nextIdx);
     var $cb = $next.closest('.cb');
     $cb.removeClass('cb-collapsed');
 
     var $filediffCollapseState = $cb.closest('.filediff').prev();
     $filediffCollapseState.prop('checked', false);
     $next.addClass('comment-selected');
     scrollToElement($next);
     return false;
   };
 
   this.nextComment = function(node) {
     return self.scrollToComment(node, 1);
   };
 
   this.prevComment = function(node) {
     return self.scrollToComment(node, -1);
   };
 
   this.nextOutdatedComment = function(node) {
     return self.scrollToComment(node, 1, true);
   };
 
   this.prevOutdatedComment = function(node) {
     return self.scrollToComment(node, -1, true);
   };
 
   this.deleteComment = function(node) {
       if (!confirm(_gettext('Delete this comment?'))) {
         return false;
       }
       var $node = $(node);
       var $td = $node.closest('td');
       var $comment = $node.closest('.comment');
       var comment_id = $comment.attr('data-comment-id');
       var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id);
       var postData = {
         '_method': 'delete',
         'csrf_token': CSRF_TOKEN
       };
 
       $comment.addClass('comment-deleting');
       $comment.hide('fast');
 
       var success = function(response) {
         $comment.remove();
         return false;
       };
       var failure = function(data, textStatus, xhr) {
         alert("error processing request: " + textStatus);
         $comment.show('fast');
         $comment.removeClass('comment-deleting');
         return false;
       };
       ajaxPOST(url, postData, success, failure);
   };
 
   this.toggleWideMode = function (node) {
       if ($('#content').hasClass('wrapper')) {
           $('#content').removeClass("wrapper");
           $('#content').addClass("wide-mode-wrapper");
           $(node).addClass('btn-success');
       } else {
           $('#content').removeClass("wide-mode-wrapper");
           $('#content').addClass("wrapper");
           $(node).removeClass('btn-success');
       }
       return false;
   };
 
   this.toggleComments = function(node, show) {
     var $filediff = $(node).closest('.filediff');
     if (show === true) {
       $filediff.removeClass('hide-comments');
     } else if (show === false) {
       $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
       $filediff.addClass('hide-comments');
     } else {
       $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
       $filediff.toggleClass('hide-comments');
     }
     return false;
   };
 
   this.toggleLineComments = function(node) {
     self.toggleComments(node, true);
     var $node = $(node);
     $node.closest('tr').toggleClass('hide-line-comments');
   };
 
+  this.createCommentForm = function(formElement, lineno, placeholderText, initAutocompleteActions, resolvesCommentId){
+      var pullRequestId = templateContext.pull_request_data.pull_request_id;
+      var commitId = templateContext.commit_data.commit_id;
+
+      var commentForm = new CommentForm(
+          formElement, commitId, pullRequestId, lineno, initAutocompleteActions, resolvesCommentId);
+      var cm = commentForm.getCmInstance();
+
+      if (resolvesCommentId){
+        var placeholderText = _gettext('Leave a comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId);
+      }
+
+      setTimeout(function() {
+          // callbacks
+          if (cm !== undefined) {
+              commentForm.setPlaceholder(placeholderText);
+              if (commentForm.isInline()) {
+                cm.focus();
+                cm.refresh();
+              }
+          }
+      }, 10);
+
+      // trigger scrolldown to the resolve comment, since it might be away
+      // from the clicked
+      if (resolvesCommentId){
+        var actionNode = $(commentForm.resolvesActionId).offset();
+
+        setTimeout(function() {
+            if (actionNode) {
+                $('body, html').animate({scrollTop: actionNode.top}, 10);
+            }
+        }, 100);
+      }
+
+      return commentForm;
+  };
+
+  this.createGeneralComment = function(lineNo, placeholderText, resolvesCommentId){
+
+      var tmpl = $('#cb-comment-general-form-template').html();
+      tmpl = tmpl.format(null, 'general');
+      var $form = $(tmpl);
+
+      var curForm = $('#cb-comment-general-form-placeholder').find('form');
+      if (curForm){
+          curForm.remove();
+      }
+      $('#cb-comment-general-form-placeholder').append($form);
+
+      var _form = $($form[0]);
+      var commentForm = this.createCommentForm(
+          _form, lineNo, placeholderText, true, resolvesCommentId);
+      commentForm.initStatusChangeSelector();
+  };
+
   this.createComment = function(node, resolutionComment) {
       var resolvesCommentId = resolutionComment || null;
       var $node = $(node);
       var $td = $node.closest('td');
       var $form = $td.find('.comment-inline-form');
 
       if (!$form.length) {
-          var tmpl = $('#cb-comment-inline-form-template').html();
+
           var $filediff = $node.closest('.filediff');
           $filediff.removeClass('hide-comments');
           var f_path = $filediff.attr('data-f-path');
           var lineno = self.getLineNumber(node);
-
+          // create a new HTML from template
+          var tmpl = $('#cb-comment-inline-form-template').html();
           tmpl = tmpl.format(f_path, lineno);
           $form = $(tmpl);
 
           var $comments = $td.find('.inline-comments');
           if (!$comments.length) {
             $comments = $(
               $('#cb-comments-inline-container-template').html());
             $td.append($comments);
           }
 
           $td.find('.cb-comment-add-button').before($form);
 
-          var pullRequestId = templateContext.pull_request_data.pull_request_id;
-          var commitId = templateContext.commit_data.commit_id;
+          var placeholderText = _gettext('Leave a comment on line {0}.').format(lineno);
           var _form = $($form[0]).find('form');
 
-          var commentForm = new CommentForm(_form, commitId, pullRequestId, lineno, false, resolvesCommentId);
-          var cm = commentForm.getCmInstance();
+          var commentForm = this.createCommentForm(
+              _form, lineno, placeholderText, false, resolvesCommentId);
+
+          $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({
+              form: _form,
+              parent: $td[0],
+              lineno: lineno,
+              f_path: f_path}
+          );
 
           // set a CUSTOM submit handler for inline comments.
           commentForm.setHandleFormSubmit(function(o) {
             var text = commentForm.cm.getValue();
             var commentType = commentForm.getCommentType();
             var resolvesCommentId = commentForm.getResolvesId();
 
             if (text === "") {
               return;
             }
 
             if (lineno === undefined) {
               alert('missing line !');
               return;
             }
             if (f_path === undefined) {
               alert('missing file path !');
               return;
             }
 
             var excludeCancelBtn = false;
             var submitEvent = true;
             commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
             commentForm.cm.setOption("readOnly", true);
             var postData = {
                 'text': text,
                 'f_path': f_path,
                 'line': lineno,
                 'comment_type': commentType,
                 'csrf_token': CSRF_TOKEN
             };
             if (resolvesCommentId){
                 postData['resolves_comment_id'] = resolvesCommentId;
             }
 
             var submitSuccessCallback = function(json_data) {
               $form.remove();
               try {
                 var html = json_data.rendered_text;
                 var lineno = json_data.line_no;
                 var target_id = json_data.target_id;
 
                 $comments.find('.cb-comment-add-button').before(html);
 
                 //mark visually which comment was resolved
                 if (resolvesCommentId) {
                     commentForm.markCommentResolved(resolvesCommentId);
                 }
 
               } catch (e) {
                 console.error(e);
               }
 
               // re trigger the linkification of next/prev navigation
               linkifyComments($('.inline-comment-injected'));
               timeagoActivate();
               bindDeleteCommentButtons();
               commentForm.setActionButtonsDisabled(false);
 
             };
             var submitFailCallback = function(){
                 commentForm.resetCommentFormState(text)
             };
             commentForm.submitAjaxPOST(
                 commentForm.submitUrl, postData, submitSuccessCallback, submitFailCallback);
           });
 
-          if (resolvesCommentId){
-              var placeholderText = _gettext('Leave a comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId);
-
-          } else {
-              var placeholderText = _gettext('Leave a comment on line {0}.').format(lineno);
-          }
-
-          setTimeout(function() {
-              // callbacks
-              if (cm !== undefined) {
-                  commentForm.setPlaceholder(placeholderText);
-                  cm.focus();
-                  cm.refresh();
-              }
-          }, 10);
-
-          $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({
-              form: _form,
-              parent: $td[0],
-              lineno: lineno,
-              f_path: f_path}
-          );
-
-          // trigger hash
-          if (resolvesCommentId){
-            var resolveAction = $(commentForm.resolvesActionId);
-            setTimeout(function() {
-                $('body, html').animate({ scrollTop: resolveAction.offset().top }, 10);
-            }, 100);
-          }
       }
 
       $form.addClass('comment-inline-form-open');
   };
 
   this.createResolutionComment = function(commentId){
     // hide the trigger text
     $('#resolve-comment-{0}'.format(commentId)).hide();
 
     var comment = $('#comment-'+commentId);
     var commentData = comment.data();
-
     if (commentData.commentInline) {
-        var resolutionComment = true;
         this.createComment(comment, commentId)
     } else {
-
-        this.createComment(comment, commentId)
-
-        console.log('TODO')
-        console.log(commentId)
+        Rhodecode.comments.createGeneralComment('general', "$placeholder", commentId)
     }
 
     return false;
   };
 
   this.submitResolution = function(commentId){
     var form = $('#resolve_comment_{0}'.format(commentId)).closest('form');
     var commentForm = form.get(0).CommentForm;
 
     var cm = commentForm.getCmInstance();
     var renderer = templateContext.visual.default_renderer;
     if (renderer == 'rst'){
         var commentUrl = '`#{0} <{1}#comment-{0}>`_'.format(commentId, commentForm.selfUrl);
     } else if (renderer == 'markdown') {
         var commentUrl = '[#{0}]({1}#comment-{0})'.format(commentId, commentForm.selfUrl);
     } else {
         var commentUrl = '{1}#comment-{0}'.format(commentId, commentForm.selfUrl);
     }
 
     cm.setValue(_gettext('TODO from comment {0} was fixed.').format(commentUrl));
     form.submit();
     return false;
   };
 
   this.renderInlineComments = function(file_comments) {
     show_add_button = typeof show_add_button !== 'undefined' ? show_add_button : true;
 
     for (var i = 0; i < file_comments.length; i++) {
       var box = file_comments[i];
 
       var target_id = $(box).attr('target_id');
 
       // actually comments with line numbers
       var comments = box.children;
 
       for (var j = 0; j < comments.length; j++) {
         var data = {
           'rendered_text': comments[j].outerHTML,
           'line_no': $(comments[j]).attr('line'),
           'target_id': target_id
         };
       }
     }
 
     // since order of injection is random, we're now re-iterating
     // from correct order and filling in links
     linkifyComments($('.inline-comment-injected'));
     bindDeleteCommentButtons();
     firefoxAnchorFix();
   };
 
 };

rhodecode/templates/changeset/changeset_file_comment.mako

@@ -1,353 +1,348 b''
 ## -*- coding: utf-8 -*-
 ## usage:
 ## <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
 ## ${comment.comment_block(comment)}
 ##
 <%namespace name="base" file="/base/base.mako"/>
 
 <%def name="comment_block(comment, inline=False)">
   <% outdated_at_ver = comment.outdated_at_version(getattr(c, 'at_version', None)) %>
   <% pr_index_ver = comment.get_index_version(getattr(c, 'versions', [])) %>
 
   <div class="comment
              ${'comment-inline' if inline else 'comment-general'}
              ${'comment-outdated' if outdated_at_ver else 'comment-current'}"
        id="comment-${comment.comment_id}"
        line="${comment.line_no}"
        data-comment-id="${comment.comment_id}"
        data-comment-type="${comment.comment_type}"
        data-comment-inline=${h.json.dumps(inline)}
        style="${'display: none;' if outdated_at_ver else ''}">
 
       <div class="meta">
           <div class="comment-type-label">
               <div class="comment-label ${comment.comment_type or 'note'}" id="comment-label-${comment.comment_id}">
               % if comment.comment_type == 'todo':
                   % if comment.resolved:
                       <div class="resolved tooltip" title="${_('Resolved by comment #{}').format(comment.resolved.comment_id)}">
                           <a href="#comment-${comment.resolved.comment_id}">${comment.comment_type}</a>
                       </div>
                   % else:
                       <div class="resolved tooltip" style="display: none">
                           <span>${comment.comment_type}</span>
                       </div>
                       <div class="resolve tooltip" onclick="return Rhodecode.comments.createResolutionComment(${comment.comment_id});" title="${_('Click to resolve this comment')}">
                         ${comment.comment_type}
                       </div>
                   % endif
               % else:
                   % if comment.resolved_comment:
                     fix
                   % else:
                     ${comment.comment_type or 'note'}
                   % endif
               % endif
               </div>
           </div>
 
           <div class="author ${'author-inline' if inline else 'author-general'}">
               ${base.gravatar_with_user(comment.author.email, 16)}
           </div>
           <div class="date">
               ${h.age_component(comment.modified_at, time_is_local=True)}
           </div>
           % if inline:
               <span></span>
           % else:
           <div class="status-change">
               % if comment.pull_request:
                   <a href="${h.url('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id)}">
                       % if comment.status_change:
                           ${_('pull request #%s') % comment.pull_request.pull_request_id}:
                       % else:
                           ${_('pull request #%s') % comment.pull_request.pull_request_id}
                       % endif
                   </a>
               % else:
                   % if comment.status_change:
                       ${_('Status change on commit')}:
                   % endif
               % endif
           </div>
           % endif
 
           % if comment.status_change:
             <div class="${'flag_status %s' % comment.status_change[0].status}"></div>
             <div title="${_('Commit status')}" class="changeset-status-lbl">
                  ${comment.status_change[0].status_lbl}
             </div>
           % endif
 
           <a class="permalink" href="#comment-${comment.comment_id}"> &para;</a>
 
           <div class="comment-links-block">
 
             % if inline:
               % if outdated_at_ver:
                   <div class="pr-version-inline">
                     <a href="${h.url.current(version=comment.pull_request_version_id, anchor='comment-{}'.format(comment.comment_id))}">
                     <code class="pr-version-num">
                         outdated ${'v{}'.format(pr_index_ver)}
                     </code>
                     </a>
                   </div>
                   |
               % endif
             % else:
                 % if comment.pull_request_version_id and pr_index_ver:
                     |
                     <div class="pr-version">
                       % if comment.outdated:
                         <a href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}">
                             ${_('Outdated comment from pull request version {}').format(pr_index_ver)}
                         </a>
                       % else:
                         <div class="tooltip" title="${_('Comment from pull request version {0}').format(pr_index_ver)}">
                             <a href="${h.url('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id, version=comment.pull_request_version_id)}">
                             <code class="pr-version-num">
                                 ${'v{}'.format(pr_index_ver)}
                             </code>
                             </a>
                         </div>
                       % endif
                     </div>
                 % endif
             % endif
 
             ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed
             ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated
             %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())):
                ## permissions to delete
                %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id:
                   ## TODO: dan: add edit comment here
                   <a onclick="return Rhodecode.comments.deleteComment(this);" class="delete-comment"> ${_('Delete')}</a>
                %else:
                   <button class="btn-link" disabled="disabled"> ${_('Delete')}</button>
                %endif
             %else:
                <button class="btn-link" disabled="disabled"> ${_('Delete')}</button>
             %endif
 
             %if not outdated_at_ver:
                | <a onclick="return Rhodecode.comments.prevComment(this);" class="prev-comment"> ${_('Prev')}</a>
                | <a onclick="return Rhodecode.comments.nextComment(this);" class="next-comment"> ${_('Next')}</a>
             %endif
 
           </div>
       </div>
       <div class="text">
           ${comment.render(mentions=True)|n}
       </div>
 
   </div>
 </%def>
 
 ## generate main comments
 <%def name="generate_comments(include_pull_request=False, is_pull_request=False)">
   <div id="comments">
     %for comment in c.comments:
         <div id="comment-tr-${comment.comment_id}">
           ## only render comments that are not from pull request, or from
           ## pull request and a status change
           %if not comment.pull_request or (comment.pull_request and comment.status_change) or include_pull_request:
           ${comment_block(comment)}
           %endif
         </div>
     %endfor
     ## to anchor ajax comments
     <div id="injected_page_comments"></div>
   </div>
 </%def>
 
 
 <%def name="comments(post_url, cur_status, is_pull_request=False, is_compare=False, change_status=True, form_extras=None)">
 
 ## merge status, and merge action
 %if is_pull_request:
 <div class="pull-request-merge">
     %if c.allowed_to_merge:
     <div class="pull-request-wrap">
         <div class="pull-right">
           ${h.secure_form(url('pullrequest_merge', repo_name=c.repo_name, pull_request_id=c.pull_request.pull_request_id), id='merge_pull_request_form')}
           <span data-role="merge-message">${c.pr_merge_msg} ${c.approval_msg if c.approval_msg else ''}</span>
           <% merge_disabled = ' disabled' if c.pr_merge_status is False else '' %>
           <input type="submit" id="merge_pull_request" value="${_('Merge Pull Request')}" class="btn${merge_disabled}"${merge_disabled}>
           ${h.end_form()}
         </div>
     </div>
     %else:
     <div class="pull-request-wrap">
         <div class="pull-right">
           <span>${c.pr_merge_msg} ${c.approval_msg if c.approval_msg else ''}</span>
         </div>
     </div>
     %endif
 </div>
 %endif
 
 <div class="comments">
     <%
       if is_pull_request:
         placeholder = _('Leave a comment on this Pull Request.')
       elif is_compare:
         placeholder = _('Leave a comment on all commits in this range.')
       else:
         placeholder = _('Leave a comment on this Commit.')
     %>
 
     % if c.rhodecode_user.username != h.DEFAULT_USER:
-    <div class="comment-form ac">
+    <div class="js-template" id="cb-comment-general-form-template">
+        ## template generated for injection
+        ${comment_form(form_type='general', review_statuses=c.commit_statuses, form_extras=form_extras)}
+    </div>
+
+    <div id="cb-comment-general-form-placeholder" class="comment-form ac">
         ## inject form here
-        ${comment_form(form_type='general', form_id='general_comment', lineno_id='general', review_statuses=c.commit_statuses, form_extras=form_extras)}
     </div>
     <script type="text/javascript">
-        // init active elements of commentForm
-        var commitId = templateContext.commit_data.commit_id;
-        var pullRequestId = templateContext.pull_request_data.pull_request_id;
         var lineNo = 'general';
-        var resolvesCommitId = null;
-
-        var mainCommentForm = new CommentForm(
-                "#general_comment", commitId, pullRequestId, lineNo, true, resolvesCommitId);
-        mainCommentForm.setPlaceholder("${placeholder}");
-        mainCommentForm.initStatusChangeSelector();
+        var resolvesCommentId = null;
+        Rhodecode.comments.createGeneralComment(lineNo, "${placeholder}", resolvesCommentId)
     </script>
-
-
     % else:
     ## form state when not logged in
     <div class="comment-form ac">
 
         <div class="comment-area">
             <div class="comment-area-header">
                 <ul class="nav-links clearfix">
                     <li class="active">
                         <a class="disabled" href="#edit-btn" disabled="disabled" onclick="return false">${_('Write')}</a>
                     </li>
                     <li class="">
                         <a class="disabled" href="#preview-btn" disabled="disabled" onclick="return false">${_('Preview')}</a>
                     </li>
                 </ul>
             </div>
 
             <div class="comment-area-write" style="display: block;">
                 <div id="edit-container">
                     <div style="padding: 40px 0">
                       ${_('You need to be logged in to leave comments.')}
                       <a href="${h.route_path('login', _query={'came_from': h.url.current()})}">${_('Login now')}</a>
                     </div>
                 </div>
                 <div id="preview-container" class="clearfix" style="display: none;">
                     <div id="preview-box" class="preview-box"></div>
                 </div>
             </div>
 
             <div class="comment-area-footer">
                 <div class="toolbar">
                     <div class="toolbar-text">
                     </div>
                 </div>
             </div>
         </div>
 
         <div class="comment-footer">
         </div>
 
     </div>
     % endif
 
     <script type="text/javascript">
         bindToggleButtons();
     </script>
 </div>
 </%def>
 
 
 <%def name="comment_form(form_type, form_id='', lineno_id='{1}', review_statuses=None, form_extras=None)">
   ## comment injected based on assumption that user is logged in
 
   <form ${'id="{}"'.format(form_id) if form_id else '' |n} action="#" method="GET">
 
     <div class="comment-area">
         <div class="comment-area-header">
             <ul class="nav-links clearfix">
                 <li class="active">
                     <a href="#edit-btn" tabindex="-1" id="edit-btn_${lineno_id}">${_('Write')}</a>
                 </li>
                 <li class="">
                     <a href="#preview-btn" tabindex="-1" id="preview-btn_${lineno_id}">${_('Preview')}</a>
                 </li>
                 <li class="pull-right">
                     <select class="comment-type" id="comment_type_${lineno_id}" name="comment_type">
                         % for val in c.visual.comment_types:
                             <option value="${val}">${val.upper()}</option>
                         % endfor
                     </select>
                 </li>
             </ul>
         </div>
 
         <div class="comment-area-write" style="display: block;">
             <div id="edit-container_${lineno_id}">
                 <textarea id="text_${lineno_id}" name="text" class="comment-block-ta ac-input"></textarea>
             </div>
             <div id="preview-container_${lineno_id}" class="clearfix" style="display: none;">
                 <div id="preview-box_${lineno_id}" class="preview-box"></div>
             </div>
         </div>
 
         <div class="comment-area-footer">
             <div class="toolbar">
                 <div class="toolbar-text">
                   ${(_('Comments parsed using %s syntax with %s support.') % (
                          ('<a href="%s">%s</a>' % (h.url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())),
                            ('<span  class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))
                        )
                     )|n}
                 </div>
             </div>
         </div>
     </div>
 
     <div class="comment-footer">
 
         % if review_statuses:
         <div class="status_box">
-          <select id="change_status" name="changeset_status">
+          <select id="change_status_${lineno_id}" name="changeset_status">
               <option></option> ## Placeholder
               % for status, lbl in review_statuses:
               <option value="${status}" data-status="${status}">${lbl}</option>
                   %if is_pull_request and change_status and status in ('approved', 'rejected'):
                       <option value="${status}_closed" data-status="${status}">${lbl} & ${_('Closed')}</option>
                   %endif
               % endfor
           </select>
         </div>
         % endif
 
         ## inject extra inputs into the form
         % if form_extras and isinstance(form_extras, (list, tuple)):
             <div id="comment_form_extras">
                 % for form_ex_el in form_extras:
                     ${form_ex_el|n}
                 % endfor
             </div>
         % endif
 
         <div class="action-buttons">
             ## inline for has a file, and line-number together with cancel hide button.
             % if form_type == 'inline':
                 <input type="hidden" name="f_path" value="{0}">
                 <input type="hidden" name="line" value="${lineno_id}">
                 <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);">
                 ${_('Cancel')}
                 </button>
             % endif
             ${h.submit('save', _('Comment'), class_='btn btn-success comment-button-input')}
 
         </div>
     </div>
 
   </form>
 
 </%def>
  No newline at end of file

rhodecode/templates/debug_style/collapsable-content.html

@@ -1,964 +1,964 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/debug_style/index.html"/>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Style'), h.url('debug_style_home'))}
     &raquo;
     ${c.active}
 </%def>
 
 
 <%def name="real_main()">
 <div class="box">
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     <div class='sidebar-col-wrapper'>
     ${self.sidebar()}
 
       <div class="main-content">
 
         <h2>Collapsable Content</h2>
         <p>Where a section may have a very long list of information, it can be desirable to use collapsable content. There is a premade function for showing/hiding elements, though its use may or may not be practical, depending on the situation. Use it, or don't, on a case-by-case basis.</p>
 
         <p><strong>To use the collapsable-content function:</strong> Create a toggle button using <code>&lt;div class="btn-collapse"&gt;Show More&lt;/div&gt;</code> and a data attribute using <code>data-toggle</code>. Clicking this button will toggle any sibling element(s) containing the class <code>collapsable-content</code> and an identical <code>data-toggle</code> attribute. It will also change the button to read "Show Less"; another click toggles it back to the previous state. Ideally, use pre-existing elements and add the class and attribute; creating a new div around the existing content may lead to unexpected results, as the toggle function will use <code>display:block</code> if no previous display specification was found.
         </p>
         <p>Notes:</p>
         <ul>
           <li>Changes made to the text of the button will require adjustment to the function, but for the sake of consistency and user experience, this is best avoided. </li>
           <li>Collapsable content inside of a pjax loaded container will require <code>collapsableContent();</code> to be called from within the container. No variables are necessary.</li>
         </ul>
 
       </div>  <!-- .main-content  -->
     </div>  <!-- .sidebar-col-wrapper  -->
 </div> <!-- .box -->
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
 
       <div class="main">
 
 <div class="box">
   <div class="title">
     <h1>
         Diff: enable filename with spaces on diffs
     </h1>
     <h1>
             <i class="icon-hg" ></i>
 
             <i class="icon-lock"></i>
         <span><a href="/rhodecode-momentum">rhodecode-momentum</a></span>
 
     </h1>
   </div>
 
   <div class="box pr-summary">
       <div class="summary-details block-left">
 
         <div class="pr-details-title">
 
     Pull request #720 From Tue, 17 Feb 2015 16:21:38
 <div class="btn-collapse" data-toggle="description">Show More</div>
         </div>
         <div id="summary" class="fields pr-details-content">
            <div class="field">
             <div class="label-summary">
                 <label>Origin:</label>
             </div>
             <div class="input">
                 <div>
                     <span class="tag">
                         <a href="/andersonsantos/rhodecode-momentum-fork#fix_574">book: fix_574</a>
                     </span>
                     <span class="clone-url">
                         <a href="/andersonsantos/rhodecode-momentum-fork">https://code.rhodecode.com/andersonsantos/rhodecode-momentum-fork</a>
                     </span>
                 </div>
                 <div>
                      <br>
                         <input type="text"  value="hg pull -r 46b3d50315f0 https://code.rhodecode.com/andersonsantos/rhodecode-momentum-fork" readonly="readonly">
                 </div>
             </div>
            </div>
            <div class="field">
             <div class="label-summary">
                 <label>Review:</label>
             </div>
             <div class="input">
               <div class="flag_status under_review tooltip pull-left" title="Pull request status calculated from votes"></div>
                 <span class="changeset-status-lbl tooltip" title="Pull request status calculated from votes">
                   Under Review
                 </span>
 
             </div>
            </div>
             <div class="field collapsable-content" data-toggle="description">
              <div class="label-summary">
                  <label>Description:</label>
              </div>
              <div class="input">
                  <div class="pr-description">Fixing issue <a class="issue- tracker-link" href="http://bugs.rhodecode.com/issues/574">#  574</a>, changing regex for capturing filenames</div>
              </div>
             </div>
             <div class="field collapsable-content" data-toggle="description">
              <div class="label-summary">
                  <label>Comments:</label>
              </div>
              <div class="input">
                  <div>
                      <div class="comments-number">
                          <a href="#inline-comments-container">0 Pull request   comments</a>,
                          0 Inline Comments
                      </div>
                  </div>
               </div>
           </div>
         </div>
       </div>
       <div>
         <div class="reviewers-title block-right">
           <div class="pr-details-title">
               Author
           </div>
         </div>
         <div class="block-right pr-details-content reviewers">
             <ul class="group_members">
               <li>
                 <img class="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=32" height="16" width="16">
                 <span class="user"> <a href="/_profiles/lolek">lolek (Lolek Santos)</a></span>
               </li>
             </ul>
         </div>
         <div class="reviewers-title block-right">
           <div class="pr-details-title">
               Pull request reviewers
               <span class="btn-collapse" data-toggle="reviewers">Show More</span>
           </div>
 
         </div>
         <div id="reviewers" class="block-right pr-details-content reviewers">
 
             <ul id="review_members" class="group_members">
               <li id="reviewer_70">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status rejected pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/153a0fab13160b3e64a2cbc7c0373506?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">jenkins-tests</a> (reviewer)</span>
                 </div>
                   <input id="reviewer_70_input" type="hidden" value="70" name="review_members">
                   <div class="reviewer_member_remove action_button" onclick="removeReviewMember(70, true)" style="visibility: hidden;">
                     <i class="icon-remove-sign"></i>
                   </div>
               </li>
               <li id="reviewer_33" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/ffd6a317ec2b66be880143cd8459d0d9?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">garbas (Rok Garbas)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_2" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status not_reviewed pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/aad9d40cac1259ea39b5578554ad9d64?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">marcink (Marcin Kuzminski)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_36" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/7a4da001a0af0016ed056ab523255db9?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">johbo (Johannes Bornhold)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_47" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/8f6dc00dce79d6bd7d415be5cea6a008?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">lisaq (Lisa Quatmann)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_49" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/89f722927932a8f737a0feafb03a606e?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">paris (Paris Kolios)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_50" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/081322c975e8545ec269372405fbd016?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">ergo (Marcin Lulek)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_54" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">anderson (Anderson Santos)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_57" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/23e2ee8f5fd462cba8129a40cc1e896c?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">gmgauthier (Greg Gauthier)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_31" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/0c9a7e6674b6f0b35d98dbe073e3f0ab?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">ostrobel (Oliver Strobel)</a> (reviewer)</span>
                 </div>
               </li>
             </ul>
           <div id="add_reviewer_input" class="ac" style="display: none;">
           </div>
         </div>
         </div>
       </div>
   </div>
   <div class="box">
       <div class="table" >
           <div id="changeset_compare_view_content">
               <div class="compare_view_commits_title">
                   <h2>Compare View: 6 commits<span class="btn-collapse" data-toggle="commits">Show More</span></h2>
 
               </div>
               <div class="container">
 
 
     <table class="rctable compare_view_commits">
     <tr>
         <th>Time</th>
         <th>Author</th>
         <th>Commit</th>
         <th></th>
         <th>Title</th>
     </tr>
         <tr id="row-7e83e5cd7812dd9e055ce30e77c65cdc08154b43" commit_id="7e83e5cd7812dd9e055ce30e77c65cdc08154b43" class="compare_select">
             <td class="td-time">
                 <span class="tooltip" title="3 hours and 23 minutes ago" tt_title="3 hours and 23 minutes ago">2015-02-18 10:13:34</span>
             </td>
             <td class="td-user">
                 <div class="gravatar_with_user">
                     <img class="gravatar" alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=16">
                     <span title="Lolek Santos <[e-mail]>" class="user">brian (Brian Butler)</span>
                 </div>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/7e83e5cd7812dd9e055ce30e77c65cdc08154b43">r395:7e83e5cd7812</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="7e83e5cd7812dd9e055ce30e77c65cdc08154b43" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-7e83e5cd7812dd9e055ce30e77c65cdc08154b43" class="message truncate">rep: added how we doc to guide</div>
                   </div>
             </td>
         </tr>
         <tr id="row-48ce1581bdb3aa7679c246cbdd3fb030623f5c87" commit_id="48ce1581bdb3aa7679c246cbdd3fb030623f5c87" class="compare_select">
             <td class="td-time">
                 <span class="tooltip" title="4 hours and 18 minutes ago">2015-02-18 09:18:31</span>
             </td>
             <td class="td-user">
                 <div class="gravatar_with_user">
                     <img class="gravatar" alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=16">
                     <span title="Lolek Santos <[e-mail]>" class="user">brian (Brian Butler)</span>
                 </div>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/48ce1581bdb3aa7679c246cbdd3fb030623f5c87">r394:48ce1581bdb3</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="48ce1581bdb3aa7679c246cbdd3fb030623f5c87" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-48ce1581bdb3aa7679c246cbdd3fb030623f5c87" class="message truncate">repo 0004 - typo</div>
                   </div>
             </td>
         </tr>
         <tr id="row-982d857aafb4c71e7686e419c32b71c9a837257d" commit_id="982d857aafb4c71e7686e419c32b71c9a837257d" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="4 hours and 22 minutes ago">2015-02-18 09:14:45</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="982d857aafb4c71e7686e419c32b71c9a837257d">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">brian (Brian Butler)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/982d857aafb4c71e7686e419c32b71c9a837257d">r393:982d857aafb4</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="982d857aafb4c71e7686e419c32b71c9a837257d" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-982d857aafb4c71e7686e419c32b71c9a837257d" class="message truncate">internals: how to doc section added</div>
                   </div>
             </td>
         </tr>
         <tr id="row-4c7258ad1af6dae91bbaf87a933e3597e676fab8" commit_id="4c7258ad1af6dae91bbaf87a933e3597e676fab8" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="20 hours and 16 minutes ago">2015-02-17 17:20:44</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="4c7258ad1af6dae91bbaf87a933e3597e676fab8">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">brian (Brian Butler)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/4c7258ad1af6dae91bbaf87a933e3597e676fab8">r392:4c7258ad1af6</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="4c7258ad1af6dae91bbaf87a933e3597e676fab8" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-4c7258ad1af6dae91bbaf87a933e3597e676fab8" class="message truncate">REP: 0004 Documentation standards</div>
                   </div>
             </td>
         </tr>
         <tr id="row-46b3d50315f0f2b1f64485ac95af4f384948f9cb" commit_id="46b3d50315f0f2b1f64485ac95af4f384948f9cb" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="18 hours and 19 minutes ago">2015-02-17 16:18:49</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="46b3d50315f0f2b1f64485ac95af4f384948f9cb">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">anderson (Anderson Santos)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/andersonsantos/rhodecode-momentum-fork/changeset/46b3d50315f0f2b1f64485ac95af4f384948f9cb">r8743:46b3d50315f0</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="46b3d50315f0f2b1f64485ac95af4f384948f9cb" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more" ></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-46b3d50315f0f2b1f64485ac95af4f384948f9cb" class="message truncate">Diff: created tests for the diff with filenames with spaces</div>
                     
                   </div>
             </td>
         </tr>
         <tr id="row-1e57d2549bd6c34798075bf05ac39f708bb33b90" commit_id="1e57d2549bd6c34798075bf05ac39f708bb33b90" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="2 days ago">2015-02-16 10:06:08</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="1e57d2549bd6c34798075bf05ac39f708bb33b90">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">anderson (Anderson Santos)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/andersonsantos/rhodecode-momentum-fork/changeset/1e57d2549bd6c34798075bf05ac39f708bb33b90">r8742:1e57d2549bd6</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="1e57d2549bd6c34798075bf05ac39f708bb33b90" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more" ></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-1e57d2549bd6c34798075bf05ac39f708bb33b90" class="message truncate">Diff: fix renaming files with spaces <a class="issue-tracker-link" href="http://bugs.rhodecode.com/issues/574">#574</a></div>
                     
                   </div>
             </td>
         </tr>
     </table>
 </div>
 
 <script>
 $('.expand_commit').on('click',function(e){
     $(this).children('i').hide();
     var cid = $(this).data('commitId');
     $('#c-'+cid).css({'height': 'auto', 'margin': '.65em 1em .65em 0','white-space': 'pre-line', 'text-overflow': 'initial', 'overflow':'visible'})
     $('#t-'+cid).css({'height': 'auto', 'text-overflow': 'initial', 'overflow':'visible', 'white-space':'normal'})
 });
 $('.compare_select').on('click',function(e){
     var cid = $(this).attr('commit_id');
     $('#row-'+cid).toggleClass('hl', !$('#row-'+cid).hasClass('hl'));
 });
 </script>
               <div class="cs_files_title">
                   <span class="cs_files_expand">
                       <span id="expand_all_files">Expand All</span> | <span id="collapse_all_files">Collapse All</span>
                   </span>
                   <h2>
                       7 files changed: 55 inserted, 9 deleted
                   </h2>
               </div>
               <div class="cs_files">
               <table class="compare_view_files">
 
                   <tr class="cs_A expand_file" fid="c--efbe5b7a3f13">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--efbe5b7a3f13"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--efbe5b7a3f13">
                           <a class="compare_view_filepath" href="#a_c--efbe5b7a3f13">
                               rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff
                           </a>
                           <span id="diff_c--efbe5b7a3f13" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">4</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--efbe5b7a3f13">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195039928">
     <div id="c--efbe5b7a3f13_target" ></div>
     <div id="c--efbe5b7a3f13" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_with_ spaces.txt b/file_with_  two spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>similarity index 100%
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>rename from file_with_ spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n4" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n4">4</a></td>
     <td class="code">
         <pre>rename to file_with_  two spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o...">...</a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n...">...</a></td>
     <td class="code no-comment">
         <pre> No newline at end of file</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
                   <tr class="cs_A expand_file" fid="c--c21377f778f9">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--c21377f778f9"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--c21377f778f9">
                           <a class="compare_view_filepath" href="#a_c--c21377f778f9">
                               rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff
                           </a>
                           <span id="diff_c--c21377f778f9" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">3</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--c21377f778f9">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195038344">
     <div id="c--c21377f778f9_target" ></div>
     <div id="c--c21377f778f9" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_changed_without_spaces.txt b/file_copied_ with  spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>copy from file_changed_without_spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>copy to file_copied_ with  spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o...">...</a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n...">...</a></td>
     <td class="code no-comment">
         <pre> No newline at end of file</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
                   <tr class="cs_A expand_file" fid="c--ee62085ad7a8">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--ee62085ad7a8"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--ee62085ad7a8">
                           <a class="compare_view_filepath" href="#a_c--ee62085ad7a8">
                               rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff
                           </a>
                           <span id="diff_c--ee62085ad7a8" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">3</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--ee62085ad7a8">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195039496">
     <div id="c--ee62085ad7a8_target" ></div>
     <div id="c--ee62085ad7a8" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_ with update.txt b/file_changed _.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>rename from file_ with update.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>rename to file_changed _.txt</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
 
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
               </table>
               </div>
           </div>
       </div>
 
 
 
 
 <div id="comment-inline-form-template" style="display: none;">
   <div class="comment-inline-form ac">
     <div class="overlay"><div class="overlay-text">Submitting...</div></div>
       <form action="#" class="inline-form" method="get">
       <div id="edit-container_{1}" class="clearfix">
         <div class="comment-title pull-left">
           Commenting on line {1}.
         </div>
         <div class="comment-help pull-right">
           Comments parsed using <a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html">RST</a> syntax with <span  class="tooltip" title="Use @username inside this text to send notification to this RhodeCode user">@mention</span> support.
         </div>
             <div style="clear: both"></div>
             <textarea id="text_{1}" name="text" class="comment-block-ta ac-input"></textarea>
       </div>
       <div id="preview-container_{1}" class="clearfix" style="display: none;">
          <div class="comment-help">
               Comment preview
           </div>
           <div id="preview-box_{1}" class="preview-box"></div>
       </div>
       <div class="comment-button pull-right">
         <input type="hidden" name="f_path" value="{0}">
         <input type="hidden" name="line" value="{1}">
         <div id="preview-btn_{1}" class="btn btn-default">Preview</div>
         <div id="edit-btn_{1}" class="btn" style="display: none;">Edit</div>
         <input class="btn btn-success save-inline-form" id="save" name="save" type="submit" value="Comment" />
       </div>
       <div class="comment-button hide-inline-form-button">
       <input class="btn hide-inline-form" id="hide-inline-form" name="hide-inline-form" type="reset" value="Cancel" />
       </div>
       </form>
   </div>
 </div>
 
 
 
 <div class="comments">
     <div id="inline-comments-container">
 
     <h2>0 Pull Request Comments</h2>
 
 
     </div>
 
 </div>
 
 
 
 
 <div class="pull-request-merge">
 </div>
 <div class="comments">
     <div class="comment-form ac">
         <form action="/rhodecode-momentum/pull-request-comment/720" id="comments_form" method="POST">
 <div style="display: none;"><input id="csrf_token" name="csrf_token" type="hidden" value="6dbc0b19ac65237df65d57202a3e1f2df4153e38" /></div>
         <div id="edit-container" class="clearfix">
             <div class="comment-title pull-left">
               Create a comment on this Pull Request.
             </div>
             <div class="comment-help pull-right">
               Comments parsed using <a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html">RST</a> syntax with <span  class="tooltip" title="Use @username inside this text to send notification to this RhodeCode user">@mention</span> support.
             </div>
              <div style="clear: both"></div>
              <textarea class="comment-block-ta" id="text" name="text"></textarea>
         </div>
 
         <div id="preview-container" class="clearfix" style="display: none;">
            <div class="comment-title">
                 Comment preview
             </div>
             <div id="preview-box" class="preview-box"></div>
         </div>
 
         <div id="comment_form_extras">
         </div>
         <div class="action-button pull-right">
             <div id="preview-btn" class="btn">
                 Preview
             </div>
             <div id="edit-btn" class="btn" style="display: none;">
                 Edit
             </div>
             <div class="comment-button">
                 <input class="btn btn-small btn-success comment-button-input" id="save" name="save" type="submit" value="Comment" />
             </div>
         </div>
         </form>
     </div>
 </div>
 <script>
 
 $(document).ready(function() {
 
     var cm = initCommentBoxCodeMirror('#text');
 
     // main form preview
     $('#preview-btn').on('click', function(e) {
         $('#preview-btn').hide();
         $('#edit-btn').show();
         var _text = cm.getValue();
         if (!_text) {
             return;
         }
         var post_data = {
             'text': _text,
             'renderer': DEFAULT_RENDERER,
             'csrf_token': CSRF_TOKEN
         };
         var previewbox = $('#preview-box');
         previewbox.addClass('unloaded');
         previewbox.html(_gettext('Loading ...'));
         $('#edit-container').hide();
         $('#preview-container').show();
 
         var url = pyroutes.url('changeset_comment_preview', {'repo_name': 'rhodecode-momentum'});
 
         ajaxPOST(url, post_data, function(o) {
             previewbox.html(o);
             previewbox.removeClass('unloaded');
         });
     });
     $('#edit-btn').on('click', function(e) {
         $('#preview-btn').show();
         $('#edit-btn').hide();
         $('#edit-container').show();
         $('#preview-container').hide();
     });
 
     var formatChangeStatus = function(state, escapeMarkup) {
         var originalOption = state.element;
         return '<div class="flag_status ' + $(originalOption).data('status') + ' pull-left"></div>' +
                '<span>' + escapeMarkup(state.text) + '</span>';
     };
 
     var formatResult = function(result, container, query, escapeMarkup) {
         return formatChangeStatus(result, escapeMarkup);
     };
 
     var formatSelection = function(data, container, escapeMarkup) {
         return formatChangeStatus(data, escapeMarkup);
     };
 
-    $('#change_status').select2({
+    $('#change_status_general').select2({
         placeholder: "Status Review",
         formatResult: formatResult,
         formatSelection: formatSelection,
         containerCssClass: "drop-menu status_box_menu",
         dropdownCssClass: "drop-menu-dropdown",
         dropdownAutoWidth: true,
         minimumResultsForSearch: -1
     });
 });
 </script>
 
 
       <script type="text/javascript">
         // TODO: switch this to pyroutes
         AJAX_COMMENT_DELETE_URL = "/rhodecode-momentum/pull-request-comment/__COMMENT_ID__/delete";
 
         $(function(){
             ReviewerAutoComplete('user');
 
             $('#open_edit_reviewers').on('click', function(e){
                 $('#open_edit_reviewers').hide();
                 $('#close_edit_reviewers').show();
                 $('#add_reviewer_input').show();
                 $('.reviewer_member_remove').css('visibility', 'visible');
             });
 
             $('#close_edit_reviewers').on('click', function(e){
                 $('#open_edit_reviewers').show();
                 $('#close_edit_reviewers').hide();
                 $('#add_reviewer_input').hide();
                 $('.reviewer_member_remove').css('visibility', 'hidden');
             });
 
             $('.show-inline-comments').on('change', function(e){
                 var show = 'none';
                 var target = e.currentTarget;
                 if(target.checked){
                     show = ''
                 }
                 var boxid = $(target).attr('id_for');
                 var comments = $('#{0} .inline-comments'.format(boxid));
                 var fn_display = function(idx){
                    $(this).css('display', show);
                 };
                 $(comments).each(fn_display);
                 var btns = $('#{0} .inline-comments-button'.format(boxid));
                 $(btns).each(fn_display);
             });
 
             var commentTotals = {};
             $.each(file_comments, function(i, comment) {
                 var path = $(comment).attr('path');
                 var comms = $(comment).children().length;
                 if (path in commentTotals) {
                     commentTotals[path] += comms;
                 } else {
                     commentTotals[path] = comms;
                 }
             });
             $.each(commentTotals, function(path, total) {
                 var elem = $('.comment-bubble[data-path="'+ path +'"]')
                 elem.css('visibility', 'visible');
                 elem.html(elem.html() + ' ' + total );
             });
 
             $('#merge_pull_request_form').submit(function() {
                 if (!$('#merge_pull_request').attr('disabled')) {
                     $('#merge_pull_request').attr('disabled', 'disabled');
                 }
                 return true;
             });
 
             $('#update_pull_request').on('click', function(e){
                 updateReviewers(undefined, "rhodecode-momentum", "720");
             });
 
             $('#update_commits').on('click', function(e){
                 updateCommits("rhodecode-momentum", "720");
             });
 
             $('#close_pull_request').on('click', function(e){
                 closePullRequest("rhodecode-momentum", "720");
             });
         })
       </script>
 
   </div>
 </div></div>
 
 </div>
 
 
 </%def>