kallithea Changeset - 166317d464f3

Changeset - 166317d464f3

Parent rev.

Child rev.

[Not reviewed]

beta

0 9 3

Marcin Kuzminski - 15 years ago 2011-05-03 14:13:37
marcin@python-works.com

Added server side file editing with commit

12 files changed with 2168 insertions and 25 deletions:

rhodecode/config/routing.py

rhodecode/controllers/files.py

rhodecode/lib/__init__.py

rhodecode/lib/auth.py

rhodecode/public/css/codemirror.css

rhodecode/public/css/style.css

rhodecode/public/js/codemirror.js

1915

rhodecode/templates/base/base.html

rhodecode/templates/base/root.html

rhodecode/templates/files/files_annotate.html

rhodecode/templates/files/files_edit.html

rhodecode/templates/files/files_source.html

0 comments (0 inline, 0 general)

rhodecode/config/routing.py

➞

Show inline comments

@@ @@ -221,128 +221,133 @@ def make_map(config): @@
                   action='add_repo')
     #USER JOURNAL
     rmap.connect('journal', '/_admin/journal', controller='journal')
     rmap.connect('public_journal', '/_admin/public_journal',
                  controller='journal', action="public_journal")
     rmap.connect('public_journal_rss', '/_admin/public_journal_rss',
                  controller='journal', action="public_journal_rss")
     rmap.connect('public_journal_atom', '/_admin/public_journal_atom',
                  controller='journal', action="public_journal_atom")
     rmap.connect('toggle_following', '/_admin/toggle_following',
                  controller='journal', action='toggle_following',
                  conditions=dict(method=["POST"]))
     #SEARCH
     rmap.connect('search', '/_admin/search', controller='search',)
     rmap.connect('search_repo', '/_admin/search/{search_repo:.*}',
                   controller='search')
     #LOGIN/LOGOUT/REGISTER/SIGN IN
     rmap.connect('login_home', '/_admin/login', controller='login')
     rmap.connect('logout_home', '/_admin/logout', controller='login',
                  action='logout')
     rmap.connect('register', '/_admin/register', controller='login',
                  action='register')
     rmap.connect('reset_password', '/_admin/password_reset',
                  controller='login', action='password_reset')
     #FEEDS
     rmap.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
                 controller='feed', action='rss',
                 conditions=dict(function=check_repo))
     rmap.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
                 controller='feed', action='atom',
                 conditions=dict(function=check_repo))
     #==========================================================================
     # REPOSITORY ROUTES
     #==========================================================================
     rmap.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
     rmap.connect('raw_changeset_home',
                  '/{repo_name:.*}/raw-changeset/{revision}',
                  controller='changeset', action='raw_changeset',
                  revision='tip', conditions=dict(function=check_repo))
     rmap.connect('summary_home', '/{repo_name:.*}',
                 controller='summary', conditions=dict(function=check_repo))
     rmap.connect('summary_home', '/{repo_name:.*}/summary',
                 controller='summary', conditions=dict(function=check_repo))
     rmap.connect('shortlog_home', '/{repo_name:.*}/shortlog',
                 controller='shortlog', conditions=dict(function=check_repo))
     rmap.connect('branches_home', '/{repo_name:.*}/branches',
                 controller='branches', conditions=dict(function=check_repo))
     rmap.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags', conditions=dict(function=check_repo))
     rmap.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
     rmap.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     rmap.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     rmap.connect('files_rawfile_home',
                  '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
                  controller='files', action='rawfile', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
     rmap.connect('files_raw_home',
                  '/{repo_name:.*}/raw/{revision}/{f_path:.*}',
                  controller='files', action='raw', revision='tip', f_path='',
                  conditions=dict(function=check_repo))
     rmap.connect('files_annotate_home',
                  '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
                  controller='files', action='annotate', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
     rmap.connect('files_edit_home',
                  '/{repo_name:.*}/edit/{revision}/{f_path:.*}',
                  controller='files', action='edit', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
     rmap.connect('files_archive_home', '/{repo_name:.*}/archive/{fname}',
                 controller='files', action='archivefile',
                 conditions=dict(function=check_repo))
     rmap.connect('repo_settings_delete', '/{repo_name:.*}/settings',
                 controller='settings', action="delete",
                 conditions=dict(method=["DELETE"], function=check_repo))
     rmap.connect('repo_settings_update', '/{repo_name:.*}/settings',
                 controller='settings', action="update",
                 conditions=dict(method=["PUT"], function=check_repo))
     rmap.connect('repo_settings_home', '/{repo_name:.*}/settings',
                 controller='settings', action='index',
                 conditions=dict(function=check_repo))
     rmap.connect('repo_fork_create_home', '/{repo_name:.*}/fork',
                 controller='settings', action='fork_create',
                 conditions=dict(function=check_repo, method=["POST"]))
     rmap.connect('repo_fork_home', '/{repo_name:.*}/fork',
                 controller='settings', action='fork',
                 conditions=dict(function=check_repo))
     rmap.connect('repo_followers_home', '/{repo_name:.*}/followers',
                  controller='followers', action='followers',
                  conditions=dict(function=check_repo))
     rmap.connect('repo_forks_home', '/{repo_name:.*}/forks',
                  controller='forks', action='forks',
                  conditions=dict(function=check_repo))
     return rmap

rhodecode/controllers/files.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.files
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Files controller for RhodeCode
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import os
 import logging
 import mimetypes
-import rhodecode.lib.helpers as h
+import traceback
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset
 from rhodecode.model.repo import RepoModel
 from vcs.backends import ARCHIVE_SPECS
 from vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \
     EmptyRepositoryError, ImproperArchiveTypeError, VCSError
 from vcs.nodes import FileNode, NodeKind
 from vcs.utils import diffs as differ
 from rhodecode.lib import convert_line_endings, detect_mode
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset
 import rhodecode.lib.helpers as h
 from rhodecode.model.repo import RepoModel
 log = logging.getLogger(__name__)
 class FilesController(BaseRepoController):
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(FilesController, self).__before__()
         c.cut_off_limit = self.cut_off_limit
     def __get_cs_or_redirect(self, rev, repo_name):
         """
         Safe way to get changeset if error occur it redirects to tip with
         proper message
         :param rev: revision to fetch
         :param repo_name: repo name to redirect after
         """
         try:
             return c.rhodecode_repo.get_changeset(rev)
         except EmptyRepositoryError, e:
             h.flash(_('There are no files yet'), category='warning')
             redirect(h.url('summary_home', repo_name=repo_name))
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name, revision='tip'))
     def __get_filenode_or_redirect(self, repo_name, cs, path):
         """
         Returns file_node, if error occurs or given path is directory,
         it'll redirect to top level path
         :param repo_name: repo_name
         :param cs: given changeset
         :param path: path to lookup
         """
         try:
             file_node = cs.get_node(path)
             if file_node.is_dir():
                 raise RepositoryError('given path is a directory')
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name,
                            revision=cs.raw_id))
         return file_node
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, repo_name, revision, f_path):
         #reditect to given revision from form if given
         post_revision = request.POST.get('at_rev', None)
         if post_revision:
             cs = self.__get_cs_or_redirect(post_revision, repo_name)
             redirect(url('files_home', repo_name=c.repo_name,
                          revision=cs.raw_id, f_path=f_path))
         c.changeset = self.__get_cs_or_redirect(revision, repo_name)
         c.branch = request.GET.get('branch', None)
         c.f_path = f_path
         cur_rev = c.changeset.revision
         #prev link
         try:
             prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)
             c.url_prev = url('files_home', repo_name=c.repo_name,
                          revision=prev_rev.raw_id, f_path=f_path)
             if c.branch:
                 c.url_prev += '?branch=%s' % c.branch
         except (ChangesetDoesNotExistError, VCSError):
             c.url_prev = '#'
         #next link
         try:
             next_rev = c.rhodecode_repo.get_changeset(cur_rev).next(c.branch)
             c.url_next = url('files_home', repo_name=c.repo_name,
                      revision=next_rev.raw_id, f_path=f_path)
             if c.branch:
                 c.url_next += '?branch=%s' % c.branch
         except (ChangesetDoesNotExistError, VCSError):
             c.url_next = '#'
         #files or dirs
         try:
             c.files_list = c.changeset.get_node(f_path)
             if c.files_list.is_file():
                 c.file_history = self._get_node_history(c.changeset, f_path)
             else:
                 c.file_history = []
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name,
                            revision=revision))
         return render('files/files.html')
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def rawfile(self, repo_name, revision, f_path):
         cs = self.__get_cs_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)
         response.content_disposition = 'attachment; filename=%s' % \
             f_path.split(os.sep)[-1].encode('utf8', 'replace')
         response.content_type = file_node.mimetype
         return file_node.content
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def raw(self, repo_name, revision, f_path):
         cs = self.__get_cs_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)
         raw_mimetype_mapping = {
             # map original mimetype to a mimetype used for "show as raw"
             # you can also provide a content-disposition to override the
             # default "attachment" disposition.
             # orig_type: (new_type, new_dispo)
             # show images inline:
             'image/x-icon': ('image/x-icon', 'inline'),
             'image/png': ('image/png', 'inline'),
             'image/gif': ('image/gif', 'inline'),
             'image/jpeg': ('image/jpeg', 'inline'),
             'image/svg+xml': ('image/svg+xml', 'inline'),
+        }
         mimetype = file_node.mimetype
         try:
             mimetype, dispo = raw_mimetype_mapping[mimetype]
         except KeyError:
             # we don't know anything special about this, handle it safely
             if file_node.is_binary:
                 # do same as download raw for binary files
                 mimetype, dispo = 'application/octet-stream', 'attachment'
             else:
                 # do not just use the original mimetype, but force text/plain,
                 # otherwise it would serve text/html and that might be unsafe.
                 # Note: underlying vcs library fakes text/plain mimetype if the
                 # mimetype can not be determined and it thinks it is not
                 # binary.This might lead to erroneous text display in some
                 # cases, but helps in other cases, like with text files
                 # without extension.
                 mimetype, dispo = 'text/plain', 'inline'
         if dispo == 'attachment':
             dispo = 'attachment; filename=%s' % \
                         f_path.split(os.sep)[-1].encode('utf8', 'replace')
         response.content_disposition = dispo
         response.content_type = mimetype
         return file_node.content
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def annotate(self, repo_name, revision, f_path):
         c.cs = self.__get_cs_or_redirect(revision, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)
         c.file_history = self._get_node_history(c.cs, f_path)
         c.f_path = f_path
         return render('files/files_annotate.html')
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def edit(self, repo_name, revision, f_path):
         r_post = request.POST
         if c.rhodecode_repo.alias == 'hg':
             from vcs.backends.hg import MercurialInMemoryChangeset as IMC
         elif c.rhodecode_repo.alias == 'git':
             from vcs.backends.git import GitInMemoryChangeset as IMC
         c.cs = self.__get_cs_or_redirect(revision, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)
         c.file_history = self._get_node_history(c.cs, f_path)
         c.f_path = f_path
         if r_post:
             old_content = c.file.content
             # modes:  0 - Unix, 1 - Mac, 2 - DOS
             mode = detect_mode(old_content.splitlines(1)[0], 0)
             content = convert_line_endings(r_post.get('content'), mode)
             message = r_post.get('message') or (_('Edited %s via RhodeCode')
                                                 % (f_path))
             if content == old_content:
                 h.flash(_('No changes'),
                     category='warning')
                 return redirect(url('changeset_home',
                                     repo_name=c.repo_name, revision='tip'))
             try:
                 new_node = FileNode(f_path, content)
                 m = IMC(c.rhodecode_repo)
                 m.change(new_node)
                 m.commit(message=message,
                          author=self.rhodecode_user.full_contact,
                          parents=[c.cs], branch=c.cs.branch)
                 h.flash(_('Successfully committed to %s' % f_path),
                         category='success')
             except Exception, e:
                 log.error(traceback.format_exc())
                 h.flash(_('Error occurred during commit'), category='error')
             return redirect(url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
         return render('files/files_edit.html')
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def archivefile(self, repo_name, fname):
         fileformat = None
         revision = None
         ext = None
         for a_type, ext_data in ARCHIVE_SPECS.items():
             archive_spec = fname.split(ext_data[1])
             if len(archive_spec) == 2 and archive_spec[1] == '':
                 fileformat = a_type or ext_data[1]
                 revision = archive_spec[0]
                 ext = ext_data[1]
         try:
             dbrepo = RepoModel().get_by_repo_name(repo_name)
             if dbrepo.enable_downloads is False:
                 return _('downloads disabled')
             cs = c.rhodecode_repo.get_changeset(revision)
             content_type = ARCHIVE_SPECS[fileformat][0]
         except ChangesetDoesNotExistError:
             return _('Unknown revision %s') % revision
         except EmptyRepositoryError:
             return _('Empty repository')
         except (ImproperArchiveTypeError, KeyError):
             return _('Unknown archive type')
         response.content_type = content_type
         response.content_disposition = 'attachment; filename=%s-%s%s' \
             % (repo_name, revision, ext)
         return cs.get_chunked_archive(stream=None, kind=fileformat)
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def diff(self, repo_name, f_path):
         diff1 = request.GET.get('diff1')
         diff2 = request.GET.get('diff2')
         c.action = request.GET.get('diff')
         c.no_changes = diff1 == diff2
         c.f_path = f_path
         c.big_diff = False
         try:
             if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)
                 node1 = c.changeset_1.get_node(f_path)
             else:
                 c.changeset_1 = EmptyChangeset(repo=c.rhodecode_repo)
                 node1 = FileNode('.', '', changeset=c.changeset_1)
             if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_2 = c.rhodecode_repo.get_changeset(diff2)
                 node2 = c.changeset_2.get_node(f_path)
             else:
                 c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)
                 node2 = FileNode('.', '', changeset=c.changeset_2)
         except RepositoryError:
             return redirect(url('files_home',
                                 repo_name=c.repo_name, f_path=f_path))
         if c.action == 'download':
             diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
                                         format='gitdiff')
             diff_name = '%s_vs_%s.diff' % (diff1, diff2)
             response.content_type = 'text/plain'
             response.content_disposition = 'attachment; filename=%s' \
                                                     % diff_name
             return diff.raw_diff()
         elif c.action == 'raw':
             diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
                                         format='gitdiff')
             response.content_type = 'text/plain'
             return diff.raw_diff()
         elif c.action == 'diff':
             if node1.is_binary or node2.is_binary:
                 c.cur_diff = _('Binary file')
             elif node1.size > self.cut_off_limit or \
                     node2.size > self.cut_off_limit:
                 c.cur_diff = ''
                 c.big_diff = True
             else:
                 diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
                                         format='gitdiff')
                 c.cur_diff = diff.as_html()
         else:
             #default option
             if node1.is_binary or node2.is_binary:
                 c.cur_diff = _('Binary file')
             elif node1.size > self.cut_off_limit or \
                     node2.size > self.cut_off_limit:
                 c.cur_diff = ''
                 c.big_diff = True
             else:
                 diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
                                         format='gitdiff')
                 c.cur_diff = diff.as_html()
         if not c.cur_diff and not c.big_diff:
             c.no_changes = True
         return render('files/file_diff.html')
     def _get_node_history(self, cs, f_path):
         changesets = cs.get_file_history(f_path)
         hist_l = []
         changesets_group = ([], _("Changesets"))
         branches_group = ([], _("Branches"))
         tags_group = ([], _("Tags"))
         for chs in changesets:
             n_desc = 'r%s:%s' % (chs.revision, chs.short_id)
             changesets_group[0].append((chs.raw_id, n_desc,))
         hist_l.append(changesets_group)
         for name, chs in c.rhodecode_repo.branches.items():
             #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         hist_l.append(branches_group)
         for name, chs in c.rhodecode_repo.tags.items():
             #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         hist_l.append(tags_group)
         return hist_l

rhodecode/lib/__init__.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.__init__
     ~~~~~~~~~~~~~~~~~~~~~~~
     Some simple helper functions
     :created_on: Jan 5, 2011
     :author: marcink
     :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 def __get_lem():
     from pygments import lexers
     from string import lower
     from collections import defaultdict
     d = defaultdict(lambda: [])
     def __clean(s):
         s = s.lstrip('*')
         s = s.lstrip('.')
         if s.find('[') != -1:
             exts = []
             start, stop = s.find('['), s.find(']')
             for suffix in s[start + 1:stop]:
                 exts.append(s[:s.find('[')] + suffix)
             return map(lower, exts)
         else:
             return map(lower, [s])
     for lx, t in sorted(lexers.LEXERS.items()):
         m = map(__clean, t[-2])
         if m:
             m = reduce(lambda x, y: x + y, m)
             for ext in m:
                 desc = lx.replace('Lexer', '')
                 d[ext].append(desc)
     return dict(d)
 # language map is also used by whoosh indexer, which for those specified
 # extensions will index it's content
 LANGUAGES_EXTENSIONS_MAP = __get_lem()
 #Additional mappings that are not present in the pygments lexers
 # NOTE: that this will overide any mappings in LANGUAGES_EXTENSIONS_MAP
 ADDITIONAL_MAPPINGS = {'xaml': 'XAML'}
 LANGUAGES_EXTENSIONS_MAP.update(ADDITIONAL_MAPPINGS)
 def str2bool(_str):
     """
     returs True/False value from given string, it tries to translate the
     string into boolean
     :param _str: string value to translate into boolean
     :rtype: boolean
     :returns: boolean from given string
     """
     if _str is None:
         return False
     if _str in (True, False):
         return _str
     _str = str(_str).strip().lower()
     return _str in ('t', 'true', 'y', 'yes', 'on', '1')
 def convert_line_endings(temp, mode):
     from string import replace
     #modes:  0 - Unix, 1 - Mac, 2 - DOS
     if mode == 0:
             temp = replace(temp, '\r\n', '\n')
             temp = replace(temp, '\r', '\n')
     elif mode == 1:
             temp = replace(temp, '\r\n', '\r')
             temp = replace(temp, '\n', '\r')
     elif mode == 2:
             import re
             temp = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", temp)
     return temp
 def detect_mode(line, default):
     if line.endswith('\r\n'):
         return 2
     elif line.endswith('\n'):
         return 0
     elif line.endswith('\r'):
         return 1
     else:
         return default
 def generate_api_key(username, salt=None):
     """
     Generates unique API key for given username,if salt is not given
     it'll be generated from some random string
     :param username: username as string
     :param salt: salt to hash generate KEY
     :rtype: str
     :returns: sha1 hash from username+salt
     """
     from tempfile import _RandomNameSequence
     import hashlib
     if salt is None:
         salt = _RandomNameSequence().next()
     return hashlib.sha1(username + salt).hexdigest()
 def safe_unicode(_str, from_encoding='utf8'):
     """
     safe unicode function. In case of UnicodeDecode error we try to return
     unicode with errors replace
     :param _str: string to decode
     :rtype: unicode
     :returns: unicode object
     """
     if isinstance(_str, unicode):
         return _str
     try:
         u_str = unicode(_str, from_encoding)
     except UnicodeDecodeError:
         u_str = unicode(_str, from_encoding, 'replace')
     return u_str
 def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):
     """
     Custom engine_from_config functions that makes sure we use NullPool for
     file based sqlite databases. This prevents errors on sqlite.
     """
     from sqlalchemy import engine_from_config as efc
     from sqlalchemy.pool import NullPool
     url = configuration[prefix + 'url']
     if url.startswith('sqlite'):
         kwargs.update({'poolclass':NullPool})
     return efc(configuration, prefix, **kwargs)

rhodecode/lib/auth.py

➞

Show inline comments

@@ @@ -185,192 +185,196 @@ def authenticate(username, password): @@
             log.debug("Authenticating user using ldap")
             kwargs = {
                   'server': ldap_settings.get('ldap_host', ''),
                   'base_dn': ldap_settings.get('ldap_base_dn', ''),
                   'port': ldap_settings.get('ldap_port'),
                   'bind_dn': ldap_settings.get('ldap_dn_user'),
                   'bind_pass': ldap_settings.get('ldap_dn_pass'),
                   'tls_kind': ldap_settings.get('ldap_tls_kind'),
                   'tls_reqcert': ldap_settings.get('ldap_tls_reqcert'),
                   'ldap_filter': ldap_settings.get('ldap_filter'),
                   'search_scope': ldap_settings.get('ldap_search_scope'),
                   'attr_login': ldap_settings.get('ldap_attr_login'),
                   'ldap_version': 3,
+                  }
             log.debug('Checking for ldap authentication')
             try:
                 aldap = AuthLdap(**kwargs)
                 (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,
                                                                 password)
                 log.debug('Got ldap DN response %s', user_dn)
                 get_ldap_attr = lambda k:ldap_attrs.get(ldap_settings\
                                                            .get(k), [''])[0]
                 user_attrs = {
                     'name': get_ldap_attr('ldap_attr_firstname'),
                     'lastname': get_ldap_attr('ldap_attr_lastname'),
                     'email': get_ldap_attr('ldap_attr_email'),
+                    }
                 if user_model.create_ldap(username, password, user_dn,
                                           user_attrs):
                     log.info('created new ldap user %s', username)
                 return True
             except (LdapUsernameError, LdapPasswordError,):
                 pass
             except (Exception,):
                 log.error(traceback.format_exc())
                 pass
     return False
 class  AuthUser(object):
     """
     A simple object that handles all attributes of user in RhodeCode
     It does lookup based on API key,given user, or user present in session
     Then it fills all required information for such user. It also checks if
     anonymous access is enabled and if so, it returns default user as logged
     in
     """
     def __init__(self, user_id=None, api_key=None):
         self.user_id = user_id
         self.api_key = None
         self.username = 'None'
         self.name = ''
         self.lastname = ''
         self.email = ''
         self.is_authenticated = False
         self.admin = False
         self.permissions = {}
         self._api_key = api_key
         self.propagate_data()
     def propagate_data(self):
         user_model = UserModel()
         self.anonymous_user = user_model.get_by_username('default', cache=True)
         if self._api_key and self._api_key != self.anonymous_user.api_key:
             #try go get user by api key
             log.debug('Auth User lookup by API KEY %s', self._api_key)
             user_model.fill_data(self, api_key=self._api_key)
         else:
             log.debug('Auth User lookup by USER ID %s', self.user_id)
             if self.user_id is not None \
                 and self.user_id != self.anonymous_user.user_id:
                 user_model.fill_data(self, user_id=self.user_id)
             else:
                 if self.anonymous_user.active is True:
                     user_model.fill_data(self,
                                          user_id=self.anonymous_user.user_id)
                     #then we set this user is logged in
                     self.is_authenticated = True
                 else:
                     self.is_authenticated = False
         log.debug('Auth User is now %s', self)
         user_model.fill_perms(self)
     @property
     def is_admin(self):
         return self.admin
     @property
     def full_contact(self):
         return '%s %s <%s>' % (self.name, self.lastname, self.email)
     def __repr__(self):
         return "<AuthUser('id:%s:%s|%s')>" % (self.user_id, self.username,
                                               self.is_authenticated)
     def set_authenticated(self, authenticated=True):
         if self.user_id != self.anonymous_user.user_id:
             self.is_authenticated = authenticated
 def set_available_permissions(config):
     """This function will propagate pylons globals with all available defined
     permission given in db. We don't want to check each time from db for new
     permissions since adding a new permission also requires application restart
     ie. to decorate new views with the newly created permission
     :param config: current pylons config instance
     """
     log.info('getting information about all available permissions')
     try:
         sa = meta.Session()
         all_perms = sa.query(Permission).all()
     except:
         pass
     finally:
         meta.Session.remove()
     config['available_permissions'] = [x.permission_name for x in all_perms]
 #==============================================================================
 # CHECK DECORATORS
 #==============================================================================
 class LoginRequired(object):
     """
     Must be logged in to execute this function else
     redirect to login page
     :param api_access: if enabled this checks only for valid auth token
         and grants access based on valid token
     """
     def __init__(self, api_access=False):
         self.api_access = api_access
     def __call__(self, func):
         return decorator(self.__wrapper, func)
     def __wrapper(self, func, *fargs, **fkwargs):
         cls = fargs[0]
         user = cls.rhodecode_user
         api_access_ok = False
         if self.api_access:
             log.debug('Checking API KEY access for %s', cls)
             if user.api_key == request.GET.get('api_key'):
                 api_access_ok = True
             else:
                 log.debug("API KEY token not valid")
         log.debug('Checking if %s is authenticated @ %s', user.username, cls)
         if user.is_authenticated or api_access_ok:
             log.debug('user %s is authenticated', user.username)
             return func(*fargs, **fkwargs)
         else:
             log.warn('user %s NOT authenticated', user.username)
             p = url.current()
             log.debug('redirecting to login page with %s', p)
             return redirect(url('login_home', came_from=p))
 class NotAnonymous(object):
     """Must be logged in to execute this function else
     redirect to login page"""
     def __call__(self, func):
         return decorator(self.__wrapper, func)
     def __wrapper(self, func, *fargs, **fkwargs):
         cls = fargs[0]
         self.user = cls.rhodecode_user
         log.debug('Checking if user is not anonymous @%s', cls)
         anonymous = self.user.username == 'default'
         if anonymous:
             p = ''
             if request.environ.get('SCRIPT_NAME') != '/':
                 p += request.environ.get('SCRIPT_NAME')
             p += request.environ.get('PATH_INFO')
             if request.environ.get('QUERY_STRING'):
                 p += '?' + request.environ.get('QUERY_STRING')

rhodecode/public/css/codemirror.css

➞

Show inline comments

@@ new file 100644 @@
 .CodeMirror {
   overflow: auto;
   height: 450px;
   line-height: 1em;
   font-family: monospace;
   _position: relative; /* IE6 hack */
+}
 .CodeMirror-gutter {
   position: absolute; left: 0; top: 0;
   background-color: #f7f7f7;
   border-right: 1px solid #eee;
   min-width: 2em;
   height: 100%;
+}
 .CodeMirror-gutter-text {
   color: #aaa;
   text-align: right;
   padding: .4em .2em .4em .4em;
+}
 .CodeMirror-lines {
   padding: .4em;
+}
 .CodeMirror pre {
   -moz-border-radius: 0;
   -webkit-border-radius: 0;
   -o-border-radius: 0;
   border-radius: 0;
   border-width: 0; margin: 0; padding: 0; background: transparent;
   font-family: inherit;
+}
 .CodeMirror-cursor {
   z-index: 10;
   position: absolute;
   visibility: hidden;
   border-left: 1px solid black !important;
+}
 .CodeMirror-focused .CodeMirror-cursor {
   visibility: visible;
+}
 span.CodeMirror-selected {
   background: #ccc !important;
   color: HighlightText !important;
+}
 .CodeMirror-focused span.CodeMirror-selected {
   background: Highlight !important;
+}
 .CodeMirror-matchingbracket {color: #0f0 !important;}
 .CodeMirror-nonmatchingbracket {color: #f22 !important;}
 .CodeMirror-gutter-text{color: #003367 !important;}
@@ \ No newline at end of file @@

rhodecode/public/css/style.css

➞

Show inline comments

@@ @@ -2111,192 +2111,201 @@ background-color:#DCE3FF; @@
 background-image:url("../images/icons/notice_msg.png");
 border:1px solid #93A8FF;
 color:#556CB5;
+}
 .success_msg,.error_msg,.notice_msg,.warning_msg {
 background-position:10px center;
 background-repeat:no-repeat;
 font-size:12px;
 font-weight:700;
 min-height:14px;
 line-height:14px;
 margin-bottom:0;
 margin-top:0;
 display:block;
 overflow:auto;
 padding:6px 10px 6px 40px;
+}
 #msg_close {
 background:transparent url("../icons/cross_grey_small.png") no-repeat scroll 0 0;
 cursor:pointer;
 height:16px;
 position:absolute;
 right:5px;
 top:5px;
 width:16px;
+}
 div#legend_container table,div#legend_choices table {
 width:auto !important;
+}
 table#permissions_manage {
 width:0 !important;
+}
 table#permissions_manage span.private_repo_msg {
 font-size:0.8em;
 opacity:0.6px;
+}
 table#permissions_manage td.private_repo_msg {
 font-size:0.8em;
+}
 table#permissions_manage tr#add_perm_input td {
 vertical-align:middle;
+}
 div.gravatar {
 background-color:#FFF;
 border:1px solid #D0D0D0;
 float:left;
 margin-right:0.7em;
 padding:2px 2px 0;
+}
 #header,#content,#footer {
 min-width:978px;
+}
 #content {
 min-height:100%;
 clear:both;
 overflow:hidden;
 padding:14px 10px;
+}
 #content div.box div.title div.search {
 background:url("../images/title_link.png") no-repeat top left;
 border-left:1px solid #316293;
+}
 #content div.box div.title div.search div.input input {
 border:1px solid #316293;
+}
 #content div.box div.title div.search div.button input.ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border:1px solid #316293;
 border-left:none;
 color:#FFF;
+}
 #content div.box input.ui-button-small {
 background:#e5e3e3 url("../images/button.png") repeat-x;
 border-top:1px solid #DDD;
 border-left:1px solid #c6c6c6;
 border-right:1px solid #DDD;
 border-bottom:1px solid #c6c6c6;
 color:#515151;
 outline:none;
 margin:0;
+}
 #content div.box input.ui-button-small-blue {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#fff;
+}
 #content div.box input.ui-button-small submit,button{
 cursor: pointer;
+}
 #content div.box div.title div.search div.button input.ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border:1px solid #316293;
 border-left:none;
 color:#FFF;
+}
 #content div.box div.form div.fields div.field div.highlight .ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#fff;
+}
 #content div.box div.form div.fields div.field div.highlight .ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border-top:1px solid #78acbf;
 border-left:1px solid #34819e;
 border-right:1px solid #35829f;
 border-bottom:1px solid #257897;
 color:#fff;
+}
 ins,div.options a:hover {
 text-decoration:none;
+}
 img,#header #header-inner #quick li a:hover span.normal,#header #header-inner #quick li ul li.last,#content div.box div.form div.fields div.field div.textarea table td table td a,#clone_url {
 border:none;
+}
 img.icon,.right .merge img {
 vertical-align:bottom;
+}
 #header ul#logged-user,#content div.box div.title ul.links,#content div.box div.message div.dismiss,#content div.box div.traffic div.legend ul {
 float:right;
 margin:0;
 padding:0;
+}
 #header #header-inner #home,#header #header-inner #logo,#content div.box ul.left,#content div.box ol.left,#content div.box div.pagination-left,div#commit_history,div#legend_data,div#legend_container,div#legend_choices {
 float:left;
+}
 #header #header-inner #quick li:hover ul ul,#header #header-inner #quick li:hover ul ul ul,#header #header-inner #quick li:hover ul ul ul ul,#content #left #menu ul.closed,#content #left #menu li ul.collapsed,.yui-tt-shadow {
 display:none;
+}
 #header #header-inner #quick li:hover ul,#header #header-inner #quick li li:hover ul,#header #header-inner #quick li li li:hover ul,#header #header-inner #quick li li li li:hover ul,#content #left #menu ul.opened,#content #left #menu li ul.expanded {
 display:block;
+}
 #content div.graph{
 padding:0 10px 10px;
+}
 #content div.box div.title ul.links li a:hover,#content div.box div.title ul.links li.ui-tabs-selected a {
 color:#bfe3ff;
+}
 #content div.box ol.lower-roman,#content div.box ol.upper-roman,#content div.box ol.lower-alpha,#content div.box ol.upper-alpha,#content div.box ol.decimal {
 margin:10px 24px 10px 44px;
+}
 #content div.box div.form,#content div.box div.table,#content div.box div.traffic {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0 20px 10px;
+}
 #content div.box div.form div.fields,#login div.form,#login div.form div.fields,#register div.form,#register div.form div.fields {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0;
+}
 #content div.box div.form div.fields div.field div.label span,#login div.form div.fields div.field div.label span,#register div.form div.fields div.field div.label span {
 height:1%;
 display:block;
 color:#363636;
 margin:0;
 padding:2px 0 0;
+}
 #content div.box div.form div.fields div.field div.input input.error,#login div.form div.fields div.field div.input input.error,#register div.form div.fields div.field div.input input.error {
 background:#FBE3E4;
 border-top:1px solid #e1b2b3;

rhodecode/public/js/codemirror.js

➞

Show inline comments

@@ new file 100644 @@
 // All functions that need access to the editor's state live inside
 // the CodeMirror function. Below that, at the bottom of the file,
 // some utilities are defined.
 // CodeMirror is the only global var we claim
 var CodeMirror = (function() {
   // This is the function that produces an editor instance. It's
   // closure is used to store the editor state.
   function CodeMirror(place, givenOptions) {
     // Determine effective options based on given values and defaults.
     var options = {}, defaults = CodeMirror.defaults;
     for (var opt in defaults)
       if (defaults.hasOwnProperty(opt))
         options[opt] = (givenOptions && givenOptions.hasOwnProperty(opt) ? givenOptions : defaults)[opt];
     // The element in which the editor lives. Takes care of scrolling
     // (if enabled).
     var wrapper = document.createElement("div");
     wrapper.className = "CodeMirror";
     // This mess creates the base DOM structure for the editor.
     wrapper.innerHTML =
       '<div style="position: relative">' + // Set to the height of the text, causes scrolling
         '<pre style="position: relative; height: 0; visibility: hidden; overflow: hidden;">' + // To measure line/char size
            '<span>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx</span></pre>' +
         '<div style="position: relative">' + // Moved around its parent to cover visible view
           '<div class="CodeMirror-gutter"><div class="CodeMirror-gutter-text"></div></div>' +
           '<div style="overflow: hidden; position: absolute; width: 0; left: 0">' + // Wraps and hides input textarea
             '<textarea style="height: 1px; position: absolute; width: 1px;" wrap="off"></textarea></div>' +
           // Provides positioning relative to (visible) text origin
           '<div class="CodeMirror-lines"><div style="position: relative">' +
             '<pre class="CodeMirror-cursor">&#160;</pre>' + // Absolutely positioned blinky cursor
             '<div></div></div></div></div></div>'; // This DIV contains the actual code
     if (place.appendChild) place.appendChild(wrapper); else place(wrapper);
     // I've never seen more elegant code in my life.
     var code = wrapper.firstChild, measure = code.firstChild, mover = measure.nextSibling,
         gutter = mover.firstChild, gutterText = gutter.firstChild,
         inputDiv = gutter.nextSibling, input = inputDiv.firstChild,
         lineSpace = inputDiv.nextSibling.firstChild, cursor = lineSpace.firstChild, lineDiv = cursor.nextSibling;
     if (options.tabindex != null) input.tabindex = options.tabindex;
     if (!options.gutter && !options.lineNumbers) gutter.style.display = "none";
     // Delayed object wrap timeouts, making sure only one is active. blinker holds an interval.
     var poll = new Delayed(), highlight = new Delayed(), blinker;
     // mode holds a mode API object. lines an array of Line objects
     // (see Line constructor), work an array of lines that should be
     // parsed, and history the undo history (instance of History
     // constructor).
     var mode, lines = [new Line("")], work, history = new History(), focused;
     loadMode();
     // The selection. These are always maintained to point at valid
     // positions. Inverted is used to remember that the user is
     // selecting bottom-to-top.
     var sel = {from: {line: 0, ch: 0}, to: {line: 0, ch: 0}, inverted: false};
     // Selection-related flags. shiftSelecting obviously tracks
     // whether the user is holding shift. reducedSelection is a hack
     // to get around the fact that we can't create inverted
     // selections. See below.
     var shiftSelecting, reducedSelection;
     // Variables used by startOperation/endOperation to track what
     // happened during the operation.
     var updateInput, changes, textChanged, selectionChanged, leaveInputAlone;
     // Current visible range (may be bigger than the view window).
     var showingFrom = 0, showingTo = 0, lastHeight = 0, curKeyId = null;
     // editing will hold an object describing the things we put in the
     // textarea, to help figure out whether something changed.
     // bracketHighlighted is used to remember that a backet has been
     // marked.
     var editing, bracketHighlighted;
     // Initialize the content. Somewhat hacky (delayed prepareInput)
     // to work around browser issues.
     operation(function(){setValue(options.value || ""); updateInput = false;})();
     setTimeout(prepareInput, 20);
     // Register our event handlers.
     connect(wrapper, "mousedown", operation(onMouseDown));
     // Gecko browsers fire contextmenu *after* opening the menu, at
     // which point we can't mess with it anymore. Context menu is
     // handled in onMouseDown for Gecko.
     if (!gecko) connect(wrapper, "contextmenu", operation(onContextMenu));
     connect(code, "dblclick", operation(onDblClick));
     connect(wrapper, "scroll", function() {updateDisplay([]); if (options.onScroll) options.onScroll(instance);});
     connect(window, "resize", function() {updateDisplay(true);});
     connect(input, "keyup", operation(onKeyUp));
     connect(input, "keydown", operation(onKeyDown));
     connect(input, "keypress", operation(onKeyPress));
     connect(input, "focus", onFocus);
     connect(input, "blur", onBlur);
     connect(wrapper, "dragenter", function(e){e.stop();});
     connect(wrapper, "dragover", function(e){e.stop();});
     connect(wrapper, "drop", operation(onDrop));
     connect(wrapper, "paste", function(){input.focus(); fastPoll();});
     connect(input, "paste", function(){fastPoll();});
     connect(input, "cut", function(){fastPoll();});
     if (document.activeElement == input) onFocus();
     else onBlur();
     function isLine(l) {return l >= 0 && l < lines.length;}
     // The instance object that we'll return. Mostly calls out to
     // local functions in the CodeMirror function. Some do some extra
     // range checking and/or clipping. operation is used to wrap the
     // call so that changes it makes are tracked, and the display is
     // updated afterwards.
     var instance = {
       getValue: getValue,
       setValue: operation(setValue),
       getSelection: getSelection,
       replaceSelection: operation(replaceSelection),
       focus: function(){input.focus(); onFocus(); fastPoll();},
       setOption: function(option, value) {
         options[option] = value;
         if (option == "lineNumbers" || option == "gutter") gutterChanged();
         else if (option == "mode" || option == "indentUnit") loadMode();
       },
       getOption: function(option) {return options[option];},
       undo: operation(undo),
       redo: operation(redo),
       indentLine: operation(function(n) {if (isLine(n)) indentLine(n, "smart");}),
       historySize: function() {return {undo: history.done.length, redo: history.undone.length};},
       matchBrackets: operation(function(){matchBrackets(true);}),
       getTokenAt: function(pos) {
         pos = clipPos(pos);
         return lines[pos.line].getTokenAt(mode, getStateBefore(pos.line), pos.ch);
       },
       cursorCoords: function(start){
         if (start == null) start = sel.inverted;
         return pageCoords(start ? sel.from : sel.to);
       },
       charCoords: function(pos){return pageCoords(clipPos(pos));},
       coordsChar: function(coords) {
         var off = eltOffset(lineSpace);
         var line = Math.min(showingTo - 1, showingFrom + Math.floor(coords.y / lineHeight()));
         return clipPos({line: line, ch: charFromX(clipLine(line), coords.x)});
       },
       getSearchCursor: function(query, pos, caseFold) {return new SearchCursor(query, pos, caseFold);},
       markText: operation(function(a, b, c){return operation(markText(a, b, c));}),
       setMarker: addGutterMarker,
       clearMarker: removeGutterMarker,
       setLineClass: operation(setLineClass),
       lineInfo: lineInfo,
       addWidget: function(pos, node, scroll) {
         var pos = localCoords(clipPos(pos), true);
         node.style.top = (showingFrom * lineHeight() + pos.yBot + paddingTop()) + "px";
         node.style.left = (pos.x + paddingLeft()) + "px";
         code.appendChild(node);
         if (scroll)
           scrollIntoView(pos.x, pos.yBot, pos.x + node.offsetWidth, pos.yBot + node.offsetHeight);
       },
       lineCount: function() {return lines.length;},
       getCursor: function(start) {
         if (start == null) start = sel.inverted;
         return copyPos(start ? sel.from : sel.to);
       },
       somethingSelected: function() {return !posEq(sel.from, sel.to);},
       setCursor: operation(function(line, ch) {
         if (ch == null && typeof line.line == "number") setCursor(line.line, line.ch);
         else setCursor(line, ch);
       }),
       setSelection: operation(function(from, to) {setSelection(clipPos(from), clipPos(to || from));}),
       getLine: function(line) {if (isLine(line)) return lines[line].text;},
       setLine: operation(function(line, text) {
         if (isLine(line)) replaceRange(text, {line: line, ch: 0}, {line: line, ch: lines[line].text.length});
       }),
       removeLine: operation(function(line) {
         if (isLine(line)) replaceRange("", {line: line, ch: 0}, clipPos({line: line+1, ch: 0}));
       }),
       replaceRange: operation(replaceRange),
       getRange: function(from, to) {return getRange(clipPos(from), clipPos(to));},
       operation: function(f){return operation(f)();},
       refresh: function(){updateDisplay(true);},
       getInputField: function(){return input;},
       getWrapperElement: function(){return wrapper;}
     };
     function setValue(code) {
       history = null;
       var top = {line: 0, ch: 0};
       updateLines(top, {line: lines.length - 1, ch: lines[lines.length-1].text.length},
                   splitLines(code), top, top);
       history = new History();
+    }
     function getValue(code) {
       var text = [];
       for (var i = 0, l = lines.length; i < l; ++i)
         text.push(lines[i].text);
       return text.join("\n");
+    }
     function onMouseDown(e) {
       // First, see if this is a click in the gutter
       for (var n = e.target(); n != wrapper; n = n.parentNode)
         if (n.parentNode == gutterText) {
           if (options.onGutterClick)
             options.onGutterClick(instance, indexOf(gutterText.childNodes, n) + showingFrom);
           return e.stop();
+        }
       if (gecko && e.button() == 3) onContextMenu(e);
       if (e.button() != 1) return;
       // For button 1, if it was clicked inside the editor
       // (posFromMouse returning non-null), we have to adjust the
       // selection.
       var start = posFromMouse(e), last = start, going;
       if (!start) {if (e.target() == wrapper) e.stop(); return;}
       setCursor(start.line, start.ch, false);
       if (!focused) onFocus();
       e.stop();
       // And then we have to see if it's a drag event, in which case
       // the dragged-over text must be selected.
       function end() {
         input.focus();
         updateInput = true;
         move(); up();
+      }
       function extend(e) {
         var cur = posFromMouse(e, true);
         if (cur && !posEq(cur, last)) {
           if (!focused) onFocus();
           last = cur;
           setSelection(start, cur);
           updateInput = false;
           var visible = visibleLines();
           if (cur.line >= visible.to || cur.line < visible.from)
             going = setTimeout(operation(function(){extend(e);}), 150);
+        }
+      }
       var move = connect(document, "mousemove", operation(function(e) {
         clearTimeout(going);
         e.stop();
         extend(e);
       }), true);
       var up = connect(document, "mouseup", operation(function(e) {
         clearTimeout(going);
         var cur = posFromMouse(e);
         if (cur) setSelection(start, cur);
         e.stop();
         end();
       }), true);
+    }
     function onDblClick(e) {
       var pos = posFromMouse(e);
       if (!pos) return;
       selectWordAt(pos);
       e.stop();
+    }
     function onDrop(e) {
       var pos = posFromMouse(e, true), files = e.e.dataTransfer.files;
       if (!pos || options.readOnly) return;
       if (files && files.length && window.FileReader && window.File) {
         var n = files.length, text = Array(n), read = 0;
         for (var i = 0; i < n; ++i) loadFile(files[i], i);
         function loadFile(file, i) {
           var reader = new FileReader;
           reader.onload = function() {
             text[i] = reader.result;
             if (++read == n) replaceRange(text.join(""), clipPos(pos), clipPos(pos));
           };
           reader.readAsText(file);
+        }
+      }
       else {
         try {
           var text = e.e.dataTransfer.getData("Text");
           if (text) replaceRange(text, pos, pos);
+        }
         catch(e){}
+      }
+    }
     function onKeyDown(e) {
       if (!focused) onFocus();
       var code = e.e.keyCode;
       // Tries to detect ctrl on non-mac, cmd on mac.
       var mod = (mac ? e.e.metaKey : e.e.ctrlKey) && !e.e.altKey, anyMod = e.e.ctrlKey || e.e.altKey || e.e.metaKey;
       if (code == 16 || e.e.shiftKey) shiftSelecting = shiftSelecting || (sel.inverted ? sel.to : sel.from);
       else shiftSelecting = null;
       // First give onKeyEvent option a chance to handle this.
       if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e.e))) return;
       if (code == 33 || code == 34) {scrollPage(code == 34); return e.stop();} // page up/down
       if (mod && (code == 36 || code == 35)) {scrollEnd(code == 36); return e.stop();} // ctrl-home/end
       if (mod && code == 65) {selectAll(); return e.stop();} // ctrl-a
       if (!options.readOnly) {
         if (!anyMod && code == 13) {return;} // enter
         if (!anyMod && code == 9 && handleTab(e.e.shiftKey)) return e.stop(); // tab
         if (mod && code == 90) {undo(); return e.stop();} // ctrl-z
         if (mod && ((e.e.shiftKey && code == 90) || code == 89)) {redo(); return e.stop();} // ctrl-shift-z, ctrl-y
+      }
       // Key id to use in the movementKeys map. We also pass it to
       // fastPoll in order to 'self learn'. We need this because
       // reducedSelection, the hack where we collapse the selection to
       // its start when it is inverted and a movement key is pressed
       // (and later restore it again), shouldn't be used for
       // non-movement keys.
       curKeyId = (mod ? "c" : "") + code;
       if (sel.inverted && movementKeys.hasOwnProperty(curKeyId)) {
         var range = selRange(input);
         if (range) {
           reducedSelection = {anchor: range.start};
           setSelRange(input, range.start, range.start);
+        }
+      }
       fastPoll(curKeyId);
+    }
     function onKeyUp(e) {
       if (reducedSelection) {
         reducedSelection = null;
         updateInput = true;
+      }
       if (e.e.keyCode == 16) shiftSelecting = null;
+    }
     function onKeyPress(e) {
       if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e.e))) return;
       if (options.electricChars && mode.electricChars) {
         var ch = String.fromCharCode(e.e.charCode == null ? e.e.keyCode : e.e.charCode);
         if (mode.electricChars.indexOf(ch) > -1)
           setTimeout(operation(function() {indentLine(sel.to.line, "smart");}), 50);
+      }
       var code = e.e.keyCode;
       // Re-stop tab and enter. Necessary on some browsers.
       if (code == 13) {handleEnter(); e.stop();}
       else if (code == 9 && options.tabMode != "default") e.stop();
       else fastPoll(curKeyId);
+    }
     function onFocus() {
       if (!focused && options.onFocus) options.onFocus(instance);
       focused = true;
       slowPoll();
       if (wrapper.className.search(/\bCodeMirror-focused\b/) == -1)
         wrapper.className += " CodeMirror-focused";
       restartBlink();
+    }
     function onBlur() {
       if (focused && options.onBlur) options.onBlur(instance);
       clearInterval(blinker);
       shiftSelecting = null;
       focused = false;
       wrapper.className = wrapper.className.replace(" CodeMirror-focused", "");
+    }
     // Replace the range from from to to by the strings in newText.
     // Afterwards, set the selection to selFrom, selTo.
     function updateLines(from, to, newText, selFrom, selTo) {
       if (history) {
         var old = [];
         for (var i = from.line, e = to.line + 1; i < e; ++i) old.push(lines[i].text);
         history.addChange(from.line, newText.length, old);
         while (history.done.length > options.undoDepth) history.done.shift();
+      }
       updateLinesNoUndo(from, to, newText, selFrom, selTo);
+    }
     function unredoHelper(from, to) {
       var change = from.pop();
       if (change) {
         var replaced = [], end = change.start + change.added;
         for (var i = change.start; i < end; ++i) replaced.push(lines[i].text);
         to.push({start: change.start, added: change.old.length, old: replaced});
         var pos = clipPos({line: change.start + change.old.length - 1,
                            ch: editEnd(replaced[replaced.length-1], change.old[change.old.length-1])});
         updateLinesNoUndo({line: change.start, ch: 0}, {line: end - 1, ch: lines[end-1].text.length}, change.old, pos, pos);
+      }
+    }
     function undo() {unredoHelper(history.done, history.undone);}
     function redo() {unredoHelper(history.undone, history.done);}
     function updateLinesNoUndo(from, to, newText, selFrom, selTo) {
       var nlines = to.line - from.line, firstLine = lines[from.line], lastLine = lines[to.line];
       // First adjust the line structure, taking some care to leave highlighting intact.
       if (firstLine == lastLine) {
         if (newText.length == 1)
           firstLine.replace(from.ch, to.ch, newText[0]);
         else {
           lastLine = firstLine.split(to.ch, newText[newText.length-1]);
           var spliceargs = [from.line + 1, nlines];
           firstLine.replace(from.ch, firstLine.text.length, newText[0]);
           for (var i = 1, e = newText.length - 1; i < e; ++i) spliceargs.push(new Line(newText[i]));
           spliceargs.push(lastLine);
           lines.splice.apply(lines, spliceargs);
+        }
+      }
       else if (newText.length == 1) {
         firstLine.replace(from.ch, firstLine.text.length, newText[0] + lastLine.text.slice(to.ch));
         lines.splice(from.line + 1, nlines);
+      }
       else {
         var spliceargs = [from.line + 1, nlines - 1];
         firstLine.replace(from.ch, firstLine.text.length, newText[0]);
         lastLine.replace(0, to.ch, newText[newText.length-1]);
         for (var i = 1, e = newText.length - 1; i < e; ++i) spliceargs.push(new Line(newText[i]));
         lines.splice.apply(lines, spliceargs);
+      }
       // Add these lines to the work array, so that they will be
       // highlighted. Adjust work lines if lines were added/removed.
       var newWork = [], lendiff = newText.length - nlines - 1;
       for (var i = 0, l = work.length; i < l; ++i) {
         var task = work[i];
         if (task < from.line) newWork.push(task);
         else if (task > to.line) newWork.push(task + lendiff);
+      }
       if (newText.length) newWork.push(from.line);
       work = newWork;
       startWorker(100);
       // Remember that these lines changed, for updating the display
       changes.push({from: from.line, to: to.line + 1, diff: lendiff});
       textChanged = true;
       // Update the selection
       function updateLine(n) {return n <= Math.min(to.line, to.line + lendiff) ? n : n + lendiff;}
       setSelection(selFrom, selTo, updateLine(sel.from.line), updateLine(sel.to.line));
       // Make sure the scroll-size div has the correct height.
       code.style.height = (lines.length * lineHeight() + 2 * paddingTop()) + "px";
+    }
     function replaceRange(code, from, to) {
       from = clipPos(from);
       if (!to) to = from; else to = clipPos(to);
       code = splitLines(code);
       function adjustPos(pos) {
         if (posLess(pos, from)) return pos;
         if (!posLess(to, pos)) return end;
         var line = pos.line + code.length - (to.line - from.line) - 1;
         var ch = pos.ch;
         if (pos.line == to.line)
           ch += code[code.length-1].length - (to.ch - (to.line == from.line ? from.ch : 0));
         return {line: line, ch: ch};
+      }
       var end;
       replaceRange1(code, from, to, function(end1) {
         end = end1;
         return {from: adjustPos(sel.from), to: adjustPos(sel.to)};
       });
       return end;
+    }
     function replaceSelection(code, collapse) {
       replaceRange1(splitLines(code), sel.from, sel.to, function(end) {
         if (collapse == "end") return {from: end, to: end};
         else if (collapse == "start") return {from: sel.from, to: sel.from};
         else return {from: sel.from, to: end};
       });
+    }
     function replaceRange1(code, from, to, computeSel) {
       var endch = code.length == 1 ? code[0].length + from.ch : code[code.length-1].length;
       var newSel = computeSel({line: from.line + code.length - 1, ch: endch});
       updateLines(from, to, code, newSel.from, newSel.to);
+    }
     function getRange(from, to) {
       var l1 = from.line, l2 = to.line;
       if (l1 == l2) return lines[l1].text.slice(from.ch, to.ch);
       var code = [lines[l1].text.slice(from.ch)];
       for (var i = l1 + 1; i < l2; ++i) code.push(lines[i].text);
       code.push(lines[l2].text.slice(0, to.ch));
       return code.join("\n");
+    }
     function getSelection() {
       return getRange(sel.from, sel.to);
+    }
     var pollingFast = false; // Ensures slowPoll doesn't cancel fastPoll
     function slowPoll() {
       if (pollingFast) return;
       poll.set(2000, function() {
         startOperation();
         readInput();
         if (focused) slowPoll();
         endOperation();
       });
+    }
     function fastPoll(keyId) {
       var missed = false;
       pollingFast = true;
       function p() {
         startOperation();
         var changed = readInput();
         if (changed == "moved" && keyId) movementKeys[keyId] = true;
         if (!changed && !missed) {missed = true; poll.set(80, p);}
         else {pollingFast = false; slowPoll();}
         endOperation();
+      }
       poll.set(20, p);
+    }
     // Inspects the textarea, compares its state (content, selection)
     // to the data in the editing variable, and updates the editor
     // content or cursor if something changed.
     function readInput() {
       var changed = false, text = input.value, sr = selRange(input);
       if (!sr) return false;
       var changed = editing.text != text, rs = reducedSelection;
       var moved = changed || sr.start != editing.start || sr.end != (rs ? editing.start : editing.end);
       if (reducedSelection && !moved && sel.from.line == 0 && sel.from.ch == 0)
         reducedSelection = null;
       else if (!moved) return false;
       if (changed) {
         shiftSelecting = reducedSelection = null;
         if (options.readOnly) {updateInput = true; return "changed";}
+      }
       // Compute selection start and end based on start/end offsets in textarea
       function computeOffset(n, startLine) {
         var pos = 0;
         for (;;) {
           var found = text.indexOf("\n", pos);
           if (found == -1 || (text.charAt(found-1) == "\r" ? found - 1 : found) >= n)
             return {line: startLine, ch: n - pos};
           ++startLine;
           pos = found + 1;
+        }
+      }
       var from = computeOffset(sr.start, editing.from),
           to = computeOffset(sr.end, editing.from);
       // Here we have to take the reducedSelection hack into account,
       // so that you can, for example, press shift-up at the start of
       // your selection and have the right thing happen.
       if (rs) {
         from = sr.start == rs.anchor ? to : from;
         to = shiftSelecting ? sel.to : sr.start == rs.anchor ? from : to;
         if (!posLess(from, to)) {
           reducedSelection = null;
           sel.inverted = false;
           var tmp = from; from = to; to = tmp;
+        }
+      }
       // In some cases (cursor on same line as before), we don't have
       // to update the textarea content at all.
       if (from.line == to.line && from.line == sel.from.line && from.line == sel.to.line && !shiftSelecting)
         updateInput = false;
       // Magic mess to extract precise edited range from the changed
       // string.
       if (changed) {
         var start = 0, end = text.length, len = Math.min(end, editing.text.length);
         var c, line = editing.from, nl = -1;
         while (start < len && (c = text.charAt(start)) == editing.text.charAt(start)) {
           ++start;
           if (c == "\n") {line++; nl = start;}
+        }
         var ch = nl > -1 ? start - nl : start, endline = editing.to - 1, edend = editing.text.length;
         for (;;) {
           c = editing.text.charAt(edend);
           if (c == "\n") endline--;
           if (text.charAt(end) != c) {++end; ++edend; break;}
           if (edend <= start || end <= start) break;
           --end; --edend;
+        }
         var nl = editing.text.lastIndexOf("\n", edend - 1), endch = nl == -1 ? edend : edend - nl - 1;
         updateLines({line: line, ch: ch}, {line: endline, ch: endch}, splitLines(text.slice(start, end)), from, to);
         if (line != endline || from.line != line) updateInput = true;
+      }
       else setSelection(from, to);
       editing.text = text; editing.start = sr.start; editing.end = sr.end;
       return changed ? "changed" : moved ? "moved" : false;
+    }
     // Set the textarea content and selection range to match the
     // editor state.
     function prepareInput() {
       var text = [];
       var from = Math.max(0, sel.from.line - 1), to = Math.min(lines.length, sel.to.line + 2);
       for (var i = from; i < to; ++i) text.push(lines[i].text);
       text = input.value = text.join(lineSep);
       var startch = sel.from.ch, endch = sel.to.ch;
       for (var i = from; i < sel.from.line; ++i)
         startch += lineSep.length + lines[i].text.length;
       for (var i = from; i < sel.to.line; ++i)
         endch += lineSep.length + lines[i].text.length;
       editing = {text: text, from: from, to: to, start: startch, end: endch};
       setSelRange(input, startch, reducedSelection ? startch : endch);
+    }
     function scrollCursorIntoView() {
       var cursor = localCoords(sel.inverted ? sel.from : sel.to);
       return scrollIntoView(cursor.x, cursor.y, cursor.x, cursor.yBot);
+    }
     function scrollIntoView(x1, y1, x2, y2) {
       var pl = paddingLeft(), pt = paddingTop();
       y1 += pt; y2 += pt; x1 += pl; x2 += pl;
       var screen = wrapper.clientHeight, screentop = wrapper.scrollTop, scrolled = false, result = true;
       if (y1 < screentop) {wrapper.scrollTop = Math.max(0, y1 - 10); scrolled = true;}
       else if (y2 > screentop + screen) {wrapper.scrollTop = y2 + 10 - screen; scrolled = true;}
       var screenw = wrapper.clientWidth, screenleft = wrapper.scrollLeft;
       if (x1 < screenleft) {wrapper.scrollLeft = Math.max(0, x1 - 10); scrolled = true;}
       else if (x2 > screenw + screenleft) {
         wrapper.scrollLeft = x2 + 10 - screenw;
         scrolled = true;
         if (x2 > code.clientWidth) result = false;
+      }
       if (scrolled && options.onScroll) options.onScroll(instance);
       return result;
+    }
     function visibleLines() {
       var lh = lineHeight(), top = wrapper.scrollTop - paddingTop();
       return {from: Math.min(lines.length, Math.max(0, Math.floor(top / lh))),
               to: Math.min(lines.length, Math.ceil((top + wrapper.clientHeight) / lh))};
+    }
     // Uses a set of changes plus the current scroll position to
     // determine which DOM updates have to be made, and makes the
     // updates.
     function updateDisplay(changes) {
       if (!wrapper.clientWidth) {
         showingFrom = showingTo = 0;
         return;
+      }
       // First create a range of theoretically intact lines, and punch
       // holes in that using the change info.
       var intact = changes === true ? [] : [{from: showingFrom, to: showingTo, domStart: 0}];
       for (var i = 0, l = changes.length || 0; i < l; ++i) {
         var change = changes[i], intact2 = [], diff = change.diff || 0;
         for (var j = 0, l2 = intact.length; j < l2; ++j) {
           var range = intact[j];
           if (change.to <= range.from)
             intact2.push({from: range.from + diff, to: range.to + diff, domStart: range.domStart});
           else if (range.to <= change.from)
             intact2.push(range);
           else {
             if (change.from > range.from)
               intact2.push({from: range.from, to: change.from, domStart: range.domStart})
             if (change.to < range.to)
               intact2.push({from: change.to + diff, to: range.to + diff,
                             domStart: range.domStart + (change.to - range.from)});
+          }
+        }
         intact = intact2;
+      }
       // Then, determine which lines we'd want to see, and which
       // updates have to be made to get there.
       var visible = visibleLines();
       var from = Math.min(showingFrom, Math.max(visible.from - 3, 0)),
           to = Math.min(lines.length, Math.max(showingTo, visible.to + 3)),
           updates = [], domPos = 0, domEnd = showingTo - showingFrom, pos = from, changedLines = 0;
       for (var i = 0, l = intact.length; i < l; ++i) {
         var range = intact[i];
         if (range.to <= from) continue;
         if (range.from >= to) break;
         if (range.domStart > domPos || range.from > pos) {
           updates.push({from: pos, to: range.from, domSize: range.domStart - domPos, domStart: domPos});
           changedLines += range.from - pos;
+        }
         pos = range.to;
         domPos = range.domStart + (range.to - range.from);
+      }
       if (domPos != domEnd || pos != to) {
         changedLines += Math.abs(to - pos);
         updates.push({from: pos, to: to, domSize: domEnd - domPos, domStart: domPos});
+      }
       if (!updates.length) return;
       lineDiv.style.display = "none";
       // If more than 30% of the screen needs update, just do a full
       // redraw (which is quicker than patching)
       if (changedLines > (visible.to - visible.from) * .3)
         refreshDisplay(from = Math.max(visible.from - 10, 0), to = Math.min(visible.to + 7, lines.length));
       // Otherwise, only update the stuff that needs updating.
       else
         patchDisplay(updates);
       lineDiv.style.display = "";
       // Position the mover div to align with the lines it's supposed
       // to be showing (which will cover the visible display)
       var different = from != showingFrom || to != showingTo || lastHeight != wrapper.clientHeight;
       showingFrom = from; showingTo = to;
       mover.style.top = (from * lineHeight()) + "px";
       if (different) {
         lastHeight = wrapper.clientHeight;
         code.style.height = (lines.length * lineHeight() + 2 * paddingTop()) + "px";
         updateGutter();
+      }
       // Since this is all rather error prone, it is honoured with the
       // only assertion in the whole file.
       if (lineDiv.childNodes.length != showingTo - showingFrom)
         throw new Error("BAD PATCH! " + JSON.stringify(updates) + " size=" + (showingTo - showingFrom) +
                         " nodes=" + lineDiv.childNodes.length);
       updateCursor();
+    }
     function refreshDisplay(from, to) {
       var html = [], start = {line: from, ch: 0}, inSel = posLess(sel.from, start) && !posLess(sel.to, start);
       for (var i = from; i < to; ++i) {
         var ch1 = null, ch2 = null;
         if (inSel) {
           ch1 = 0;
           if (sel.to.line == i) {inSel = false; ch2 = sel.to.ch;}
+        }
         else if (sel.from.line == i) {
           if (sel.to.line == i) {ch1 = sel.from.ch; ch2 = sel.to.ch;}
           else {inSel = true; ch1 = sel.from.ch;}
+        }
         html.push(lines[i].getHTML(ch1, ch2, true));
+      }
       lineDiv.innerHTML = html.join("");
+    }
     function patchDisplay(updates) {
       // Slightly different algorithm for IE (badInnerHTML), since
       // there .innerHTML on PRE nodes is dumb, and discards
       // whitespace.
       var sfrom = sel.from.line, sto = sel.to.line, off = 0,
           scratch = badInnerHTML && document.createElement("div");
       for (var i = 0, e = updates.length; i < e; ++i) {
         var rec = updates[i];
         var extra = (rec.to - rec.from) - rec.domSize;
         var nodeAfter = lineDiv.childNodes[rec.domStart + rec.domSize + off] || null;
         if (badInnerHTML)
           for (var j = Math.max(-extra, rec.domSize); j > 0; --j)
             lineDiv.removeChild(nodeAfter ? nodeAfter.previousSibling : lineDiv.lastChild);
         else if (extra) {
           for (var j = Math.max(0, extra); j > 0; --j)
             lineDiv.insertBefore(document.createElement("pre"), nodeAfter);
           for (var j = Math.max(0, -extra); j > 0; --j)
             lineDiv.removeChild(nodeAfter ? nodeAfter.previousSibling : lineDiv.lastChild);
+        }
         var node = lineDiv.childNodes[rec.domStart + off], inSel = sfrom < rec.from && sto >= rec.from;
         for (var j = rec.from; j < rec.to; ++j) {
           var ch1 = null, ch2 = null;
           if (inSel) {
             ch1 = 0;
             if (sto == j) {inSel = false; ch2 = sel.to.ch;}
+          }
           else if (sfrom == j) {
             if (sto == j) {ch1 = sel.from.ch; ch2 = sel.to.ch;}
             else {inSel = true; ch1 = sel.from.ch;}
+          }
           if (badInnerHTML) {
             scratch.innerHTML = lines[j].getHTML(ch1, ch2, true);
             lineDiv.insertBefore(scratch.firstChild, nodeAfter);
+          }
           else {
             node.innerHTML = lines[j].getHTML(ch1, ch2, false);
             node.className = lines[j].className || "";
             node = node.nextSibling;
+          }
+        }
         off += extra;
+      }
+    }
     function updateGutter() {
       if (!options.gutter && !options.lineNumbers) return;
       var hText = mover.offsetHeight, hEditor = wrapper.clientHeight;
       gutter.style.height = (hText - hEditor < 2 ? hEditor : hText) + "px";
       var html = [];
       for (var i = showingFrom; i < showingTo; ++i) {
         var marker = lines[i].gutterMarker;
         var text = options.lineNumbers ? i + options.firstLineNumber : null;
         if (marker && marker.text)
           text = marker.text.replace("%N%", text != null ? text : "");
         else if (text == null)
           text = "\u00a0";
         html.push((marker && marker.style ? '<pre class="' + marker.style + '">' : "<pre>"), text, "</pre>");
+      }
       gutter.style.display = "none";
       gutterText.innerHTML = html.join("");
       var minwidth = String(lines.length).length, firstNode = gutterText.firstChild, val = eltText(firstNode), pad = "";
       while (val.length + pad.length < minwidth) pad += "\u00a0";
       if (pad) firstNode.insertBefore(document.createTextNode(pad), firstNode.firstChild);
       gutter.style.display = "";
       lineSpace.style.marginLeft = gutter.offsetWidth + "px";
+    }
     function updateCursor() {
       var head = sel.inverted ? sel.from : sel.to;
       var x = charX(head.line, head.ch) + "px", y = (head.line - showingFrom) * lineHeight() + "px";
       inputDiv.style.top = y; inputDiv.style.left = x;
       if (posEq(sel.from, sel.to)) {
         cursor.style.top = y; cursor.style.left = x;
         cursor.style.display = "";
+      }
       else cursor.style.display = "none";
+    }
     // Update the selection. Last two args are only used by
     // updateLines, since they have to be expressed in the line
     // numbers before the update.
     function setSelection(from, to, oldFrom, oldTo) {
       if (posEq(sel.from, from) && posEq(sel.to, to)) return;
       var sh = shiftSelecting && clipPos(shiftSelecting);
       if (posLess(to, from)) {var tmp = to; to = from; from = tmp;}
       if (sh) {
         if (posLess(sh, from)) from = sh;
         else if (posLess(to, sh)) to = sh;
+      }
       var startEq = posEq(sel.to, to), endEq = posEq(sel.from, from);
       if (posEq(from, to)) sel.inverted = false;
       else if (startEq && !endEq) sel.inverted = true;
       else if (endEq && !startEq) sel.inverted = false;
       // Some ugly logic used to only mark the lines that actually did
       // see a change in selection as changed, rather than the whole
       // selected range.
       if (oldFrom == null) {oldFrom = sel.from.line; oldTo = sel.to.line;}
       if (posEq(from, to)) {
         if (!posEq(sel.from, sel.to))
           changes.push({from: oldFrom, to: oldTo + 1});
+      }
       else if (posEq(sel.from, sel.to)) {
         changes.push({from: from.line, to: to.line + 1});
+      }
       else {
         if (!posEq(from, sel.from)) {
           if (from.line < oldFrom)
             changes.push({from: from.line, to: Math.min(to.line, oldFrom) + 1});
           else
             changes.push({from: oldFrom, to: Math.min(oldTo, from.line) + 1});
+        }
         if (!posEq(to, sel.to)) {
           if (to.line < oldTo)
             changes.push({from: Math.max(oldFrom, from.line), to: oldTo + 1});
           else
             changes.push({from: Math.max(from.line, oldTo), to: to.line + 1});
+        }
+      }
       sel.from = from; sel.to = to;
       selectionChanged = true;
+    }
     function setCursor(line, ch) {
       var pos = clipPos({line: line, ch: ch || 0});
       setSelection(pos, pos);
+    }
     function clipLine(n) {return Math.max(0, Math.min(n, lines.length-1));}
     function clipPos(pos) {
       if (pos.line < 0) return {line: 0, ch: 0};
       if (pos.line >= lines.length) return {line: lines.length-1, ch: lines[lines.length-1].text.length};
       var ch = pos.ch, linelen = lines[pos.line].text.length;
       if (ch == null || ch > linelen) return {line: pos.line, ch: linelen};
       else if (ch < 0) return {line: pos.line, ch: 0};
       else return pos;
+    }
     function scrollPage(down) {
       var linesPerPage = Math.floor(wrapper.clientHeight / lineHeight()), head = sel.inverted ? sel.from : sel.to;
       setCursor(head.line + (Math.max(linesPerPage - 1, 1) * (down ? 1 : -1)), head.ch);
+    }
     function scrollEnd(top) {
       setCursor(top ? 0 : lines.length - 1);
+    }
     function selectAll() {
       var endLine = lines.length - 1;
       setSelection({line: 0, ch: 0}, {line: endLine, ch: lines[endLine].text.length});
+    }
     function selectWordAt(pos) {
       var line = lines[pos.line].text;
       var start = pos.ch, end = pos.ch;
       while (start > 0 && /\w/.test(line.charAt(start - 1))) --start;
       while (end < line.length - 1 && /\w/.test(line.charAt(end))) ++end;
       setSelection({line: pos.line, ch: start}, {line: pos.line, ch: end});
+    }
     function handleEnter() {
       replaceSelection("\n", "end");
       if (options.enterMode != "flat")
         indentLine(sel.from.line, options.enterMode == "keep" ? "prev" : "smart");
+    }
     function handleTab(shift) {
       shiftSelecting = null;
       switch (options.tabMode) {
       case "default":
         return false;
       case "indent":
         for (var i = sel.from.line, e = sel.to.line; i <= e; ++i) indentLine(i, "smart");
         break;
       case "classic":
         if (posEq(sel.from, sel.to)) {
           if (shift) indentLine(sel.from.line, "smart");
           else replaceSelection("\t", "end");
           break;
+        }
       case "shift":
         for (var i = sel.from.line, e = sel.to.line; i <= e; ++i) indentLine(i, shift ? "subtract" : "add");
         break;
+      }
       return true;
+    }
     function indentLine(n, how) {
       if (how == "smart") {
         if (!mode.indent) how = "prev";
         else var state = getStateBefore(n);
+      }
       var line = lines[n], curSpace = line.indentation(), curSpaceString = line.text.match(/^\s*/)[0], indentation;
       if (how == "prev") {
         if (n) indentation = lines[n-1].indentation();
         else indentation = 0;
+      }
       else if (how == "smart") indentation = mode.indent(state, line.text.slice(curSpaceString.length));
       else if (how == "add") indentation = curSpace + options.indentUnit;
       else if (how == "subtract") indentation = curSpace - options.indentUnit;
       indentation = Math.max(0, indentation);
       var diff = indentation - curSpace;
       if (!diff) {
         if (sel.from.line != n && sel.to.line != n) return;
         var indentString = curSpaceString;
+      }
       else {
         var indentString = "", pos = 0;
         if (options.indentWithTabs)
           for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
         while (pos < indentation) {++pos; indentString += " ";}
+      }
       replaceRange(indentString, {line: n, ch: 0}, {line: n, ch: curSpaceString.length});
+    }
     function loadMode() {
       mode = CodeMirror.getMode(options, options.mode);
       for (var i = 0, l = lines.length; i < l; ++i)
         lines[i].stateAfter = null;
       work = [0];
+    }
     function gutterChanged() {
       var visible = options.gutter || options.lineNumbers;
       gutter.style.display = visible ? "" : "none";
       if (visible) updateGutter();
       else lineDiv.parentNode.style.marginLeft = 0;
+    }
     function markText(from, to, className) {
       from = clipPos(from); to = clipPos(to);
       var accum = [];
       function add(line, from, to, className) {
         var line = lines[line], mark = line.addMark(from, to, className);
         mark.line = line;
         accum.push(mark);
+      }
       if (from.line == to.line) add(from.line, from.ch, to.ch, className);
       else {
         add(from.line, from.ch, null, className);
         for (var i = from.line + 1, e = to.line; i < e; ++i)
           add(i, 0, null, className);
         add(to.line, 0, to.ch, className);
+      }
       changes.push({from: from.line, to: to.line + 1});
       return function() {
         var start, end;
         for (var i = 0; i < accum.length; ++i) {
           var mark = accum[i], found = indexOf(lines, mark.line);
           mark.line.removeMark(mark);
           if (found > -1) {
             if (start == null) start = found;
             end = found;
+          }
+        }
         if (start != null) changes.push({from: start, to: end + 1});
       };
+    }
     function addGutterMarker(line, text, className) {
       if (typeof line == "number") line = lines[clipLine(line)];
       line.gutterMarker = {text: text, style: className};
       updateGutter();
       return line;
+    }
     function removeGutterMarker(line) {
       if (typeof line == "number") line = lines[clipLine(line)];
       line.gutterMarker = null;
       updateGutter();
+    }
     function setLineClass(line, className) {
       if (typeof line == "number") {
         var no = line;
         line = lines[clipLine(line)];
+      }
       else {
         var no = indexOf(lines, line);
         if (no == -1) return null;
+      }
       line.className = className;
       changes.push({from: no, to: no + 1});
       return line;
+    }
     function lineInfo(line) {
       if (typeof line == "number") {
         var n = line;
         line = lines[line];
         if (!line) return null;
+      }
       else {
         var n = indexOf(lines, line);
         if (n == -1) return null;
+      }
       var marker = line.gutterMarker;
       return {line: n, text: line.text, markerText: marker && marker.text, markerClass: marker && marker.style};
+    }
     // These are used to go from pixel positions to character
     // positions, taking tabs into account.
     function charX(line, pos) {
       var text = lines[line].text, span = measure.firstChild;
       if (text.lastIndexOf("\t", pos) == -1) return pos * charWidth();
       var old = span.firstChild.nodeValue;
       try {
         span.firstChild.nodeValue = text.slice(0, pos);
         return span.offsetWidth;
       } finally {span.firstChild.nodeValue = old;}
+    }
     function charFromX(line, x) {
       var text = lines[line].text, cw = charWidth();
       if (x <= 0) return 0;
       if (text.indexOf("\t") == -1) return Math.min(text.length, Math.round(x / cw));
       var mspan = measure.firstChild, mtext = mspan.firstChild, old = mtext.nodeValue;
       try {
         mtext.nodeValue = text;
         var from = 0, fromX = 0, to = text.length, toX = mspan.offsetWidth;
         if (x > toX) return to;
         for (;;) {
           if (to - from <= 1) return (toX - x > x - fromX) ? from : to;
           var middle = Math.ceil((from + to) / 2);
           mtext.nodeValue = text.slice(0, middle);
           var curX = mspan.offsetWidth;
           if (curX > x) {to = middle; toX = curX;}
           else {from = middle; fromX = curX;}
+        }
       } finally {mtext.nodeValue = old;}
+    }
     function localCoords(pos, inLineWrap) {
       var lh = lineHeight(), line = pos.line - (inLineWrap ? showingFrom : 0);
       return {x: charX(pos.line, pos.ch), y: line * lh, yBot: (line + 1) * lh};
+    }
     function pageCoords(pos) {
       var local = localCoords(pos, true), off = eltOffset(lineSpace);
       return {x: off.left + local.x, y: off.top + local.y, yBot: off.top + local.yBot};
+    }
     function lineHeight() {
       var nlines = lineDiv.childNodes.length;
       if (nlines) return lineDiv.offsetHeight / nlines;
       else return measure.firstChild.offsetHeight || 1;
+    }
     function charWidth() {return (measure.firstChild.offsetWidth || 320) / 40;}
     function paddingTop() {return lineSpace.offsetTop;}
     function paddingLeft() {return lineSpace.offsetLeft;}
     function posFromMouse(e, liberal) {
       var off = eltOffset(lineSpace),
           x = e.pageX() - off.left,
           y = e.pageY() - off.top;
       if (!liberal && e.target() != lineSpace.parentNode && !(e.target() == wrapper && y > (lines.length * lineHeight())))
         for (var n = e.target(); n != lineDiv && n != cursor; n = n.parentNode)
           if (!n || n == wrapper) return null;
       var line = showingFrom + Math.floor(y / lineHeight());
       return clipPos({line: line, ch: charFromX(clipLine(line), x)});
+    }
     function onContextMenu(e) {
       var pos = posFromMouse(e);
       if (!pos || window.opera) return; // Opera is difficult.
       if (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to))
         setCursor(pos.line, pos.ch);
       var oldCSS = input.style.cssText;
       input.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.pageY() - 1) +
         "px; left: " + (e.pageX() - 1) + "px; z-index: 1000; background: white; " +
         "border-width: 0; outline: none; overflow: hidden;";
       var val = input.value = getSelection();
       input.focus();
       setSelRange(input, 0, val.length);
       if (gecko) e.stop();
       leaveInputAlone = true;
       setTimeout(function() {
         if (input.value != val) operation(replaceSelection)(input.value, "end");
         input.style.cssText = oldCSS;
         leaveInputAlone = false;
         prepareInput();
         slowPoll();
       }, 50);
+    }
     // Cursor-blinking
     function restartBlink() {
       clearInterval(blinker);
       var on = true;
       cursor.style.visibility = "";
       blinker = setInterval(function() {
         cursor.style.visibility = (on = !on) ? "" : "hidden";
       }, 650);
+    }
     var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
     function matchBrackets(autoclear) {
       var head = sel.inverted ? sel.from : sel.to, line = lines[head.line], pos = head.ch - 1;
       var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
       if (!match) return;
       var ch = match.charAt(0), forward = match.charAt(1) == ">", d = forward ? 1 : -1, st = line.styles;
       for (var off = pos + 1, i = 0, e = st.length; i < e; i+=2)
         if ((off -= st[i].length) <= 0) {var style = st[i+1]; break;}
       var stack = [line.text.charAt(pos)], re = /[(){}[\]]/;
       function scan(line, from, to) {
         if (!line.text) return;
         var st = line.styles, pos = forward ? 0 : line.text.length - 1, cur;
         for (var i = forward ? 0 : st.length - 2, e = forward ? st.length : -2; i != e; i += 2*d) {
           var text = st[i];
           if (st[i+1] != null && st[i+1] != style) {pos += d * text.length; continue;}
           for (var j = forward ? 0 : text.length - 1, te = forward ? text.length : -1; j != te; j += d, pos+=d) {
             if (pos >= from && pos < to && re.test(cur = text.charAt(j))) {
               var match = matching[cur];
               if (match.charAt(1) == ">" == forward) stack.push(cur);
               else if (stack.pop() != match.charAt(0)) return {pos: pos, match: false};
               else if (!stack.length) return {pos: pos, match: true};
+            }
+          }
+        }
+      }
       for (var i = head.line, e = forward ? Math.min(i + 50, lines.length) : Math.max(0, i - 50); i != e; i+=d) {
         var line = lines[i], first = i == head.line;
         var found = scan(line, first && forward ? pos + 1 : 0, first && !forward ? pos : line.text.length);
         if (found) {
           var style = found.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
           var one = markText({line: head.line, ch: pos}, {line: head.line, ch: pos+1}, style),
               two = markText({line: i, ch: found.pos}, {line: i, ch: found.pos + 1}, style);
           var clear = operation(function(){one(); two();});
           if (autoclear) setTimeout(clear, 800);
           else bracketHighlighted = clear;
           break;
+        }
+      }
+    }
     // Finds the line to start with when starting a parse. Tries to
     // find a line with a stateAfter, so that it can start with a
     // valid state. If that fails, it returns the line with the
     // smallest indentation, which tends to need the least context to
     // parse correctly.
     function findStartLine(n) {
       var minindent, minline;
       for (var search = n, lim = n - 40; search > lim; --search) {
         if (search == 0) return 0;
         var line = lines[search-1];
         if (line.stateAfter) return search;
         var indented = line.indentation();
         if (minline == null || minindent > indented) {
           minline = search;
           minindent = indented;
+        }
+      }
       return minline;
+    }
     function getStateBefore(n) {
       var start = findStartLine(n), state = start && lines[start-1].stateAfter;
       if (!state) state = startState(mode);
       else state = copyState(mode, state);
       for (var i = start; i < n; ++i) {
         var line = lines[i];
         line.highlight(mode, state);
         line.stateAfter = copyState(mode, state);
+      }
       if (!lines[n].stateAfter) work.push(n);
       return state;
+    }
     function highlightWorker() {
       var end = +new Date + options.workTime;
       while (work.length) {
         if (!lines[showingFrom].stateAfter) var task = showingFrom;
         else var task = work.pop();
         if (task >= lines.length) continue;
         var start = findStartLine(task), state = start && lines[start-1].stateAfter;
         if (state) state = copyState(mode, state);
         else state = startState(mode);
         for (var i = start, l = lines.length; i < l; ++i) {
           var line = lines[i], hadState = line.stateAfter;
           if (+new Date > end) {
             work.push(i);
             startWorker(options.workDelay);
             changes.push({from: task, to: i});
             return;
+          }
           var changed = line.highlight(mode, state);
           line.stateAfter = copyState(mode, state);
           if (hadState && !changed && line.text) break;
+        }
         changes.push({from: task, to: i});
+      }
+    }
     function startWorker(time) {
       if (!work.length) return;
       highlight.set(time, operation(highlightWorker));
+    }
     // Operations are used to wrap changes in such a way that each
     // change won't have to update the cursor and display (which would
     // be awkward, slow, and error-prone), but instead updates are
     // batched and then all combined and executed at once.
     function startOperation() {
       updateInput = null; changes = []; textChanged = selectionChanged = false;
+    }
     function endOperation() {
       var reScroll = false;
       if (selectionChanged) reScroll = !scrollCursorIntoView();
       if (changes.length) updateDisplay(changes);
       else if (selectionChanged) updateCursor();
       if (reScroll) scrollCursorIntoView();
       if (selectionChanged) restartBlink();
       // updateInput can be set to a boolean value to force/prevent an
       // update.
       if (!leaveInputAlone && (updateInput === true || (updateInput !== false && selectionChanged)))
         prepareInput();
       if (selectionChanged && options.onCursorActivity)
         options.onCursorActivity(instance);
       if (textChanged && options.onChange)
         options.onChange(instance);
       if (selectionChanged && options.matchBrackets)
         setTimeout(operation(function() {
           if (bracketHighlighted) {bracketHighlighted(); bracketHighlighted = null;}
           matchBrackets(false);
         }), 20);
+    }
     var nestedOperation = 0;
     function operation(f) {
       return function() {
         if (!nestedOperation++) startOperation();
         try {var result = f.apply(this, arguments);}
         finally {if (!--nestedOperation) endOperation();}
         return result;
       };
+    }
     function SearchCursor(query, pos, caseFold) {
       this.atOccurrence = false;
       if (caseFold == null) caseFold = typeof query == "string" && query == query.toLowerCase();
       if (pos && typeof pos == "object") pos = clipPos(pos);
       else pos = {line: 0, ch: 0};
       this.pos = {from: pos, to: pos};
       // The matches method is filled in based on the type of query.
       // It takes a position and a direction, and returns an object
       // describing the next occurrence of the query, or null if no
       // more matches were found.
       if (typeof query != "string") // Regexp match
         this.matches = function(reverse, pos) {
           if (reverse) {
             var line = lines[pos.line].text.slice(0, pos.ch), match = line.match(query), start = 0;
             while (match) {
               var ind = line.indexOf(match[0]);
               start += ind;
               line = line.slice(ind + 1);
               var newmatch = line.match(query);
               if (newmatch) match = newmatch;
               else break;
+            }
+          }
           else {
             var line = lines[pos.line].text.slice(pos.ch), match = line.match(query),
                 start = match && pos.ch + line.indexOf(match[0]);
+          }
           if (match)
             return {from: {line: pos.line, ch: start},
                     to: {line: pos.line, ch: start + match[0].length},
                     match: match};
         };
       else { // String query
         if (caseFold) query = query.toLowerCase();
         var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
         var target = query.split("\n");
         // Different methods for single-line and multi-line queries
         if (target.length == 1)
           this.matches = function(reverse, pos) {
             var line = fold(lines[pos.line].text), len = query.length, match;
             if (reverse ? (pos.ch >= len && (match = line.lastIndexOf(query, pos.ch - len)) != -1)
                         : (match = line.indexOf(query, pos.ch)) != -1)
               return {from: {line: pos.line, ch: match},
                       to: {line: pos.line, ch: match + len}};
           };
         else
           this.matches = function(reverse, pos) {
             var ln = pos.line, idx = (reverse ? target.length - 1 : 0), match = target[idx], line = fold(lines[ln].text);
             var offsetA = (reverse ? line.indexOf(match) + match.length : line.lastIndexOf(match));
             if (reverse ? offsetA >= pos.ch || offsetA != match.length
                         : offsetA <= pos.ch || offsetA != line.length - match.length)
               return;
             for (;;) {
               if (reverse ? !ln : ln == lines.length - 1) return;
               line = fold(lines[ln += reverse ? -1 : 1].text);
               match = target[reverse ? --idx : ++idx];
               if (idx > 0 && idx < target.length - 1) {
                 if (line != match) return;
                 else continue;
+              }
               var offsetB = (reverse ? line.lastIndexOf(match) : line.indexOf(match) + match.length);
               if (reverse ? offsetB != line.length - match.length : offsetB != match.length)
                 return;
               var start = {line: pos.line, ch: offsetA}, end = {line: ln, ch: offsetB};
               return {from: reverse ? end : start, to: reverse ? start : end};
+            }
           };
+      }
+    }
     SearchCursor.prototype = {
       findNext: function() {return this.find(false);},
       findPrevious: function() {return this.find(true);},
       find: function(reverse) {
         var self = this, pos = clipPos(reverse ? this.pos.from : this.pos.to);
         function savePosAndFail(line) {
           var pos = {line: line, ch: 0};
           self.pos = {from: pos, to: pos};
           self.atOccurrence = false;
           return false;
+        }
         for (;;) {
           if (this.pos = this.matches(reverse, pos)) {
             this.atOccurrence = true;
             return this.pos.match || true;
+          }
           if (reverse) {
             if (!pos.line) return savePosAndFail(0);
             pos = {line: pos.line-1, ch: lines[pos.line-1].text.length};
+          }
           else {
             if (pos.line == lines.length - 1) return savePosAndFail(lines.length);
             pos = {line: pos.line+1, ch: 0};
+          }
+        }
       },
       from: function() {if (this.atOccurrence) return copyPos(this.pos.from);},
       to: function() {if (this.atOccurrence) return copyPos(this.pos.to);}
     };
     return instance;
   } // (end of function CodeMirror)
   // The default configuration options.
   CodeMirror.defaults = {
     value: "",
     mode: null,
     indentUnit: 2,
     indentWithTabs: false,
     tabMode: "classic",
     enterMode: "indent",
     electricChars: true,
     onKeyEvent: null,
     lineNumbers: false,
     gutter: false,
     firstLineNumber: 1,
     readOnly: false,
     onChange: null,
     onCursorActivity: null,
     onGutterClick: null,
     onFocus: null, onBlur: null, onScroll: null,
     matchBrackets: false,
     workTime: 100,
     workDelay: 200,
     undoDepth: 40,
     tabindex: null
   };
   // Known modes, by name and by MIME
   var modes = {}, mimeModes = {};
   CodeMirror.defineMode = function(name, mode) {
     if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
     modes[name] = mode;
   };
   CodeMirror.defineMIME = function(mime, spec) {
     mimeModes[mime] = spec;
   };
   CodeMirror.getMode = function(options, spec) {
     if (typeof spec == "string" && mimeModes.hasOwnProperty(spec))
       spec = mimeModes[spec];
     if (typeof spec == "string")
       var mname = spec, config = {};
     else
       var mname = spec.name, config = spec;
     var mfactory = modes[mname];
     if (!mfactory) {
       if (window.console) console.warn("No mode " + mname + " found, falling back to plain text.");
       return CodeMirror.getMode(options, "text/plain");
+    }
     return mfactory(options, config);
+  }
   CodeMirror.listModes = function() {
     var list = [];
     for (var m in modes)
       if (modes.propertyIsEnumerable(m)) list.push(m);
     return list;
   };
   CodeMirror.listMIMEs = function() {
     var list = [];
     for (var m in mimeModes)
       if (mimeModes.propertyIsEnumerable(m)) list.push(m);
     return list;
   };
   CodeMirror.fromTextArea = function(textarea, options) {
     if (!options) options = {};
     options.value = textarea.value;
     if (!options.tabindex && textarea.tabindex)
       options.tabindex = textarea.tabindex;
     function save() {textarea.value = instance.getValue();}
     if (textarea.form) {
       // Deplorable hack to make the submit method do the right thing.
       var rmSubmit = connect(textarea.form, "submit", save, true);
       if (typeof textarea.form.submit == "function") {
         var realSubmit = textarea.form.submit;
         function wrappedSubmit() {
           save();
           textarea.form.submit = realSubmit;
           textarea.form.submit();
           textarea.form.submit = wrappedSubmit;
+        }
         textarea.form.submit = wrappedSubmit;
+      }
+    }
     textarea.style.display = "none";
     var instance = CodeMirror(function(node) {
       textarea.parentNode.insertBefore(node, textarea.nextSibling);
     }, options);
     instance.save = save;
     instance.toTextArea = function() {
       save();
       textarea.parentNode.removeChild(instance.getWrapperElement());
       textarea.style.display = "";
       if (textarea.form) {
         rmSubmit();
         if (typeof textarea.form.submit == "function")
           textarea.form.submit = realSubmit;
+      }
     };
     return instance;
   };
   // Utility functions for working with state. Exported because modes
   // sometimes need to do this.
   function copyState(mode, state) {
     if (state === true) return state;
     if (mode.copyState) return mode.copyState(state);
     var nstate = {};
     for (var n in state) {
       var val = state[n];
       if (val instanceof Array) val = val.concat([]);
       nstate[n] = val;
+    }
     return nstate;
+  }
   CodeMirror.startState = startState;
   function startState(mode, a1, a2) {
     return mode.startState ? mode.startState(a1, a2) : true;
+  }
   CodeMirror.copyState = copyState;
   // The character stream used by a mode's parser.
   function StringStream(string) {
     this.pos = this.start = 0;
     this.string = string;
+  }
   StringStream.prototype = {
     eol: function() {return this.pos >= this.string.length;},
     sol: function() {return this.pos == 0;},
     peek: function() {return this.string.charAt(this.pos);},
     next: function() {
       if (this.pos < this.string.length)
         return this.string.charAt(this.pos++);
     },
     eat: function(match) {
       var ch = this.string.charAt(this.pos);
       if (typeof match == "string") var ok = ch == match;
       else var ok = ch && (match.test ? match.test(ch) : match(ch));
       if (ok) {++this.pos; return ch;}
     },
     eatWhile: function(match) {
       var start = this.start;
       while (this.eat(match)){}
       return this.pos > start;
     },
     eatSpace: function() {
       var start = this.pos;
       while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
       return this.pos > start;
     },
     skipToEnd: function() {this.pos = this.string.length;},
     skipTo: function(ch) {
       var found = this.string.indexOf(ch, this.pos);
       if (found > -1) {this.pos = found; return true;}
     },
     backUp: function(n) {this.pos -= n;},
     column: function() {return countColumn(this.string, this.start);},
     indentation: function() {return countColumn(this.string);},
     match: function(pattern, consume, caseInsensitive) {
       if (typeof pattern == "string") {
         function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
         if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {
           if (consume !== false) this.pos += pattern.length;
           return true;
+        }
+      }
       else {
         var match = this.string.slice(this.pos).match(pattern);
         if (match && consume !== false) this.pos += match[0].length;
         return match;
+      }
     },
     current: function(){return this.string.slice(this.start, this.pos);}
   };
   // Line objects. These hold state related to a line, including
   // highlighting info (the styles array).
   function Line(text, styles) {
     this.styles = styles || [text, null];
     this.stateAfter = null;
     this.text = text;
     this.marked = this.gutterMarker = this.className = null;
+  }
   Line.prototype = {
     // Replace a piece of a line, keeping the styles around it intact.
     replace: function(from, to, text) {
       var st = [], mk = this.marked;
       copyStyles(0, from, this.styles, st);
       if (text) st.push(text, null);
       copyStyles(to, this.text.length, this.styles, st);
       this.styles = st;
       this.text = this.text.slice(0, from) + text + this.text.slice(to);
       this.stateAfter = null;
       if (mk) {
         var diff = text.length - (to - from), end = this.text.length;
         function fix(n) {return n <= Math.min(to, to + diff) ? n : n + diff;}
         for (var i = 0; i < mk.length; ++i) {
           var mark = mk[i], del = false;
           if (mark.from >= end) del = true;
           else {mark.from = fix(mark.from); if (mark.to != null) mark.to = fix(mark.to);}
           if (del || mark.from >= mark.to) {mk.splice(i, 1); i--;}
+        }
+      }
     },
     // Split a line in two, again keeping styles intact.
     split: function(pos, textBefore) {
       var st = [textBefore, null];
       copyStyles(pos, this.text.length, this.styles, st);
       return new Line(textBefore + this.text.slice(pos), st);
     },
     addMark: function(from, to, style) {
       var mk = this.marked, mark = {from: from, to: to, style: style};
       if (this.marked == null) this.marked = [];
       this.marked.push(mark);
       this.marked.sort(function(a, b){return a.from - b.from;});
       return mark;
     },
     removeMark: function(mark) {
       var mk = this.marked;
       if (!mk) return;
       for (var i = 0; i < mk.length; ++i)
         if (mk[i] == mark) {mk.splice(i, 1); break;}
     },
     // Run the given mode's parser over a line, update the styles
     // array, which contains alternating fragments of text and CSS
     // classes.
     highlight: function(mode, state) {
       var stream = new StringStream(this.text), st = this.styles, pos = 0, changed = false;
       while (!stream.eol()) {
         var style = mode.token(stream, state);
         var substr = this.text.slice(stream.start, stream.pos);
         stream.start = stream.pos;
         if (pos && st[pos-1] == style)
           st[pos-2] += substr;
         else if (substr) {
           if (!changed && st[pos] != substr || st[pos+1] != style) changed = true;
           st[pos++] = substr; st[pos++] = style;
+        }
         // Give up when line is ridiculously long
         if (stream.pos > 5000) {
           st[pos++] = this.text.slice(stream.pos); st[pos++] = null;
           break;
+        }
+      }
       if (st.length != pos) {st.length = pos; changed = true;}
       return changed;
     },
     // Fetch the parser token for a given character. Useful for hacks
     // that want to inspect the mode state (say, for completion).
     getTokenAt: function(mode, state, ch) {
       var txt = this.text, stream = new StringStream(txt);
       while (stream.pos < ch && !stream.eol()) {
         stream.start = stream.pos;
         var style = mode.token(stream, state);
+      }
       return {start: stream.start,
               end: stream.pos,
               string: stream.current(),
               className: style || null,
               state: state};
     },
     indentation: function() {return countColumn(this.text);},
     // Produces an HTML fragment for the line, taking selection,
     // marking, and highlighting into account.
     getHTML: function(sfrom, sto, includePre) {
       var html = [];
       if (includePre)
         html.push(this.className ? '<pre class="' + this.className + '">': "<pre>");
       function span(text, style) {
         if (!text) return;
         if (style) html.push('<span class="', style, '">', htmlEscape(text), "</span>");
         else html.push(htmlEscape(text));
+      }
       var st = this.styles, allText = this.text, marked = this.marked;
       if (sfrom == sto) sfrom = null;
       if (!allText)
         span(" ", sfrom != null && sto == null ? "CodeMirror-selected" : null);
       else if (!marked && sfrom == null)
         for (var i = 0, e = st.length; i < e; i+=2) span(st[i], st[i+1]);
       else {
         var pos = 0, i = 0, text = "", style, sg = 0;
         var markpos = -1, mark = null;
         function nextMark() {
           if (marked) {
             markpos += 1;
             mark = (markpos < marked.length) ? marked[markpos] : null;
+          }
+        }
         nextMark();
         while (pos < allText.length) {
           var upto = allText.length;
           var extraStyle = "";
           if (sfrom != null) {
             if (sfrom > pos) upto = sfrom;
             else if (sto == null || sto > pos) {
               extraStyle = " CodeMirror-selected";
               if (sto != null) upto = Math.min(upto, sto);
+            }
+          }
           while (mark && mark.to != null && mark.to <= pos) nextMark();
           if (mark) {
             if (mark.from > pos) upto = Math.min(upto, mark.from);
             else {
               extraStyle += " " + mark.style;
               if (mark.to != null) upto = Math.min(upto, mark.to);
+            }
+          }
           for (;;) {
             var end = pos + text.length;
             var apliedStyle = style;
             if (extraStyle) apliedStyle = style ? style + extraStyle : extraStyle;
             span(end > upto ? text.slice(0, upto - pos) : text, apliedStyle);
             if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}
             pos = end;
             text = st[i++]; style = st[i++];
+          }
+        }
         if (sfrom != null && sto == null) span(" ", "CodeMirror-selected");
+      }
       if (includePre) html.push("</pre>");
       return html.join("");
+    }
   };
   // Utility used by replace and split above
   function copyStyles(from, to, source, dest) {
     for (var i = 0, pos = 0, state = 0; pos < to; i+=2) {
       var part = source[i], end = pos + part.length;
       if (state == 0) {
         if (end > from) dest.push(part.slice(from - pos, Math.min(part.length, to - pos)), source[i+1]);
         if (end >= from) state = 1;
+      }
       else if (state == 1) {
         if (end > to) dest.push(part.slice(0, to - pos), source[i+1]);
         else dest.push(part, source[i+1]);
+      }
       pos = end;
+    }
+  }
   // The history object 'chunks' changes that are made close together
   // and at almost the same time into bigger undoable units.
   function History() {
     this.time = 0;
     this.done = []; this.undone = [];
+  }
   History.prototype = {
     addChange: function(start, added, old) {
       this.undone.length = 0;
       var time = +new Date, last = this.done[this.done.length - 1];
       if (time - this.time > 400 || !last ||
           last.start > start + added || last.start + last.added < start - last.added + last.old.length)
         this.done.push({start: start, added: added, old: old});
       else {
         var oldoff = 0;
         if (start < last.start) {
           for (var i = last.start - start - 1; i >= 0; --i)
             last.old.unshift(old[i]);
           last.added += last.start - start;
           last.start = start;
+        }
         else if (last.start < start) {
           oldoff = start - last.start;
           added += oldoff;
+        }
         for (var i = last.added - oldoff, e = old.length; i < e; ++i)
           last.old.push(old[i]);
         if (last.added < added) last.added = added;
+      }
       this.time = time;
+    }
   };
   // Event stopping compatibility wrapper.
   function stopEvent() {
     if (this.preventDefault) {this.preventDefault(); this.stopPropagation();}
     else {this.returnValue = false; this.cancelBubble = true;}
+  }
   // Ensure an event has a stop method.
   function addStop(event) {
     if (!event.stop) event.stop = stopEvent;
     return event;
+  }
   // Event wrapper, exposing the few operations we need.
   function Event(orig) {this.e = orig;}
   Event.prototype = {
     stop: function() {stopEvent.call(this.e);},
     target: function() {return this.e.target || this.e.srcElement;},
     button: function() {
       if (this.e.which) return this.e.which;
       else if (this.e.button & 1) return 1;
       else if (this.e.button & 2) return 3;
       else if (this.e.button & 4) return 2;
     },
     pageX: function() {
       if (this.e.pageX != null) return this.e.pageX;
       else return this.e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
     },
     pageY: function() {
       if (this.e.pageY != null) return this.e.pageY;
       else return this.e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
+    }
   };
   // Event handler registration. If disconnect is true, it'll return a
   // function that unregisters the handler.
   function connect(node, type, handler, disconnect) {
     function wrapHandler(event) {handler(new Event(event || window.event));}
     if (typeof node.addEventListener == "function") {
       node.addEventListener(type, wrapHandler, false);
       if (disconnect) return function() {node.removeEventListener(type, wrapHandler, false);};
+    }
     else {
       node.attachEvent("on" + type, wrapHandler);
       if (disconnect) return function() {node.detachEvent("on" + type, wrapHandler);};
+    }
+  }
   function Delayed() {this.id = null;}
   Delayed.prototype = {set: function(ms, f) {clearTimeout(this.id); this.id = setTimeout(f, ms);}};
   // Some IE versions don't preserve whitespace when setting the
   // innerHTML of a PRE tag.
   var badInnerHTML = (function() {
     var pre = document.createElement("pre");
     pre.innerHTML = " "; return !pre.innerHTML;
   })();
   var gecko = /gecko\/\d{7}/i.test(navigator.userAgent);
   var lineSep = "\n";
   // Feature-detect whether newlines in textareas are converted to \r\n
   (function () {
     var te = document.createElement("textarea");
     te.value = "foo\nbar";
     if (te.value.indexOf("\r") > -1) lineSep = "\r\n";
   }());
   var tabSize = 8;
   var mac = /Mac/.test(navigator.platform);
   var movementKeys = {};
   for (var i = 35; i <= 40; ++i)
     movementKeys[i] = movementKeys["c" + i] = true;
   // Counts the column offset in a string, taking tabs into account.
   // Used mostly to find indentation.
   function countColumn(string, end) {
     if (end == null) {
       end = string.search(/[^\s\u00a0]/);
       if (end == -1) end = string.length;
+    }
     for (var i = 0, n = 0; i < end; ++i) {
       if (string.charAt(i) == "\t") n += tabSize - (n % tabSize);
       else ++n;
+    }
     return n;
+  }
   // Find the position of an element by following the offsetParent chain.
   function eltOffset(node) {
     var x = 0, y = 0, n2 = node;
     for (var n = node; n; n = n.offsetParent) {x += n.offsetLeft; y += n.offsetTop;}
     for (var n = node; n != document.body; n = n.parentNode) {x -= n.scrollLeft; y -= n.scrollTop;}
     return {left: x, top: y};
+  }
   // Get a node's text content.
   function eltText(node) {
     return node.textContent || node.innerText || node.nodeValue || "";
+  }
   // Operations on {line, ch} objects.
   function posEq(a, b) {return a.line == b.line && a.ch == b.ch;}
   function posLess(a, b) {return a.line < b.line || (a.line == b.line && a.ch < b.ch);}
   function copyPos(x) {return {line: x.line, ch: x.ch};}
   function htmlEscape(str) {
     return str.replace(/[<&]/g, function(str) {return str == "&" ? "&amp;" : "&lt;";});
+  }
   // Used to position the cursor after an undo/redo by finding the
   // last edited character.
   function editEnd(from, to) {
     if (!to) return from ? from.length : 0;
     if (!from) return to.length;
     for (var i = from.length, j = to.length; i >= 0 && j >= 0; --i, --j)
       if (from.charAt(i) != to.charAt(j)) break;
     return j + 1;
+  }
   function indexOf(collection, elt) {
     if (collection.indexOf) return collection.indexOf(elt);
     for (var i = 0, e = collection.length; i < e; ++i)
       if (collection[i] == elt) return i;
     return -1;
+  }
   // See if "".split is the broken IE version, if so, provide an
   // alternative way to split lines.
   if ("\n\nb".split(/\n/).length != 3)
     var splitLines = function(string) {
       var pos = 0, nl, result = [];
       while ((nl = string.indexOf("\n", pos)) > -1) {
         result.push(string.slice(pos, string.charAt(nl-1) == "\r" ? nl - 1 : nl));
         pos = nl + 1;
+      }
       result.push(string.slice(pos));
       return result;
     };
   else
     var splitLines = function(string){return string.split(/\r?\n/);};
   // Sane model of finding and setting the selection in a textarea
   if (window.getSelection) {
     var selRange = function(te) {
       try {return {start: te.selectionStart, end: te.selectionEnd};}
       catch(e) {return null;}
     };
     var setSelRange = function(te, start, end) {
       try {te.setSelectionRange(start, end);}
       catch(e) {} // Fails on Firefox when textarea isn't part of the document
     };
+  }
   // IE model. Don't ask.
   else {
     var selRange = function(te) {
       try {var range = document.selection.createRange();}
       catch(e) {return null;}
       if (!range || range.parentElement() != te) return null;
       var val = te.value, len = val.length, localRange = te.createTextRange();
       localRange.moveToBookmark(range.getBookmark());
       var endRange = te.createTextRange();
       endRange.collapse(false);
       if (localRange.compareEndPoints("StartToEnd", endRange) > -1)
         return {start: len, end: len};
       var start = -localRange.moveStart("character", -len);
       for (var i = val.indexOf("\r"); i > -1 && i < start; i = val.indexOf("\r", i+1), start++) {}
       if (localRange.compareEndPoints("EndToEnd", endRange) > -1)
         return {start: start, end: len};
       var end = -localRange.moveEnd("character", -len);
       for (var i = val.indexOf("\r"); i > -1 && i < end; i = val.indexOf("\r", i+1), end++) {}
       return {start: start, end: end};
     };
     var setSelRange = function(te, start, end) {
       var range = te.createTextRange();
       range.collapse(true);
       var endrange = range.duplicate();
       var newlines = 0, txt = te.value;
       for (var pos = txt.indexOf("\n"); pos > -1 && pos < start; pos = txt.indexOf("\n", pos + 1))
         ++newlines;
       range.move("character", start - newlines);
       for (; pos > -1 && pos < end; pos = txt.indexOf("\n", pos + 1))
         ++newlines;
       endrange.move("character", end - newlines);
       range.setEndPoint("EndToEnd", endrange);
       range.select();
     };
+  }
   CodeMirror.defineMode("null", function() {
     return {token: function(stream) {stream.skipToEnd();}};
   });
   CodeMirror.defineMIME("text/plain", "null");
   return CodeMirror;
 })();

rhodecode/templates/base/base.html

➞

Show inline comments

@@ @@ -174,182 +174,179 @@ @@
 								   failure:function(o){
 									   YUD.removeClass('repo_switcher','loaded');
+								   }
 							   },null);
+						   }
 						   return false;
 					   });
 					</script>
 				</li>
 	            <li ${is_current('summary')}>
 	               <a title="${_('Summary')}" href="${h.url('summary_home',repo_name=c.repo_name)}">
 	               <span class="icon">
 	                   <img src="${h.url("/images/icons/clipboard_16.png")}" alt="${_('Summary')}" />
 	               </span>
 	               <span>${_('Summary')}</span>
 	               </a>
 	            </li>
                 ##<li ${is_current('shortlog')}>
                 ##   <a title="${_('Shortlog')}" href="${h.url('shortlog_home',repo_name=c.repo_name)}">
                 ##   <span class="icon">
                 ##       <img src="${h.url("/images/icons/application_view_list.png")}" alt="${_('Shortlog')}" />
                 ##   </span>
                 ##   <span>${_('Shortlog')}</span>
                 ##   </a>
                 ##</li>
                 <li ${is_current('changelog')}>
                    <a title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=c.repo_name)}">
                    <span class="icon">
                        <img src="${h.url("/images/icons/time.png")}" alt="${_('Changelog')}" />
                    </span>
                    <span>${_('Changelog')}</span>
                    </a>
                 </li>
                 <li ${is_current('switch_to')}>
                    <a title="${_('Switch to')}" href="#">
                    <span class="icon">
                        <img src="${h.url("/images/icons/arrow_switch.png")}" alt="${_('Switch to')}" />
                    </span>
                    <span>${_('Switch to')}</span>
                    </a>
                     <ul>
                         <li>
                             ${h.link_to('%s (%s)' % (_('branches'),len(c.rhodecode_repo.branches.values()),),h.url('branches_home',repo_name=c.repo_name),class_='branches childs')}
                             <ul>
                             %if c.rhodecode_repo.branches.values():
 						        %for cnt,branch in enumerate(c.rhodecode_repo.branches.items()):
 						            <li>${h.link_to('%s - %s' % (branch[0],h.short_id(branch[1])),h.url('files_home',repo_name=c.repo_name,revision=branch[1]))}</li>
 						        %endfor
 						    %else:
 						    	<li>${h.link_to(_('There are no branches yet'),'#')}</li>
 						    %endif
                             </ul>
                         </li>
                         <li>
                             ${h.link_to('%s (%s)' % (_('tags'),len(c.rhodecode_repo.tags.values()),),h.url('tags_home',repo_name=c.repo_name),class_='tags childs')}
                             <ul>
                             %if c.rhodecode_repo.tags.values():
                                 %for cnt,tag in enumerate(c.rhodecode_repo.tags.items()):
                                  <li>${h.link_to('%s - %s' % (tag[0],h.short_id(tag[1])),h.url('files_home',repo_name=c.repo_name,revision=tag[1]))}</li>
                                 %endfor
                             %else:
                             	<li>${h.link_to(_('There are no tags yet'),'#')}</li>
                             %endif
                             </ul>
                         </li>
                     </ul>
                 </li>
                 <li ${is_current('files')}>
                    <a title="${_('Files')}" href="${h.url('files_home',repo_name=c.repo_name)}">
                    <span class="icon">
                        <img src="${h.url("/images/icons/file.png")}" alt="${_('Files')}" />
                    </span>
                    <span>${_('Files')}</span>
                    </a>
                 </li>
                 <li ${is_current('options')}>
                    <a title="${_('Options')}" href="#">
                    <span class="icon">
                        <img src="${h.url("/images/icons/table_gear.png")}" alt="${_('Admin')}" />
                    </span>
                    <span>${_('Options')}</span>
                    </a>
                    <ul>
                    %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
                      %if h.HasPermissionAll('hg.admin')('access settings on repository'):
                          <li>${h.link_to(_('settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>
                      %else:
                          <li>${h.link_to(_('settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>
                      %endif
                    %endif
                    	<li>${h.link_to(_('fork'),h.url('repo_fork_home',repo_name=c.repo_name),class_='fork')}</li>
                    	<li>${h.link_to(_('search'),h.url('search_repo',search_repo=c.repo_name),class_='search')}</li>
                     %if h.HasPermissionAll('hg.admin')('access admin main page'):
                     <li>
                     % if h.HasPermissionAll('hg.admin')('access admin main page'):
                      <li>
                        ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}
                         <%def name="admin_menu()">
                         <ul>
                             <li>${h.link_to(_('journal'),h.url('admin_home'),class_='journal')}</li>
                             <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>
                             <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>
                             <li>${h.link_to(_('users groups'),h.url('users_groups'),class_='groups')}</li>
                             <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>
                             <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>
                             <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>
                         </ul>
                         </%def>
                         ${admin_menu()}
                     </li>
                     %endif
                      </li>
                     % endif
                    </ul>
                 </li>
                 <li>
                     <a title="${_('Followers')}" href="${h.url('repo_followers_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url("/images/icons/heart.png")}" alt="${_('Followers')}" />
                     </span>
                     <span id="current_followers_count" class="short">${c.repository_followers}</span>
                     </a>
                 </li>
                 <li>
                     <a title="${_('Forks')}" href="${h.url('repo_forks_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url("/images/icons/arrow_divide.png")}" alt="${_('Forks')}" />
                     </span>
                     <span class="short">${c.repository_forks}</span>
                     </a>
                 </li>
 	        </ul>
 		%else:
 		    ##ROOT MENU
             <ul id="quick">
                 <li>
                     <a title="${_('Home')}"  href="${h.url('home')}">
                     <span class="icon">
                         <img src="${h.url("/images/icons/home_16.png")}" alt="${_('Home')}" />
                     </span>
                     <span>${_('Home')}</span>
                     </a>
                 </li>
                 %if c.rhodecode_user.username != 'default':
                 <li>
                 % if c.rhodecode_user.username != 'default':
                  <li>
                     <a title="${_('Journal')}"  href="${h.url('journal')}">
                     <span class="icon">
                         <img src="${h.url("/images/icons/book.png")}" alt="${_('Journal')}" />
                     </span>
                     <span>${_('Journal')}</span>
                     </a>
                 </li>
                 %endif
                  </li>
                 % endif
                 <li>
                     <a title="${_('Search')}"  href="${h.url('search')}">
                     <span class="icon">
                         <img src="${h.url("/images/icons/search_16.png")}" alt="${_('Search')}" />
                     </span>
                     <span>${_('Search')}</span>
                     </a>
                 </li>
 				%if h.HasPermissionAll('hg.admin')('access admin main page'):
                 <li ${is_current('admin')}>
                    <a title="${_('Admin')}" href="${h.url('admin_home')}">
                    <span class="icon">
                        <img src="${h.url("/images/icons/cog_edit.png")}" alt="${_('Admin')}" />
                    </span>
                    <span>${_('Admin')}</span>
                    </a>
                     ${admin_menu()}
                 </li>
 				%endif
 			</ul>
 		%endif
 </%def>
@@ \ No newline at end of file @@

rhodecode/templates/base/root.html

➞

Show inline comments

 ## -*- coding: utf-8 -*-
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
         <title>${self.title()}</title>
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
         <meta name="robots" content="index, nofollow"/>
         <link rel="icon" href="${h.url("/images/icons/database_gear.png")}" type="image/png" />
         <!-- stylesheets -->
         ${self.css()}
         %if c.ga_code:
         <!-- Analytics -->
 	     <script type="text/javascript">
 	      var _gaq = _gaq || [];
 	      _gaq.push(['_setAccount', '${c.ga_code}']);
 	      _gaq.push(['_trackPageview']);
 	      (function() {
 	        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
 	        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 	        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 	      })();
 	     </script>
 	    %endif
         <!-- scripts -->
         ${self.js()}
     </head>
     <body id="body">
         ${next.body()}
     </body>
 </html>
 <%def name="css()">
     <link rel="stylesheet" type="text/css" href="${h.url('/css/style.css')}" media="screen" />
 	<link rel="stylesheet" type="text/css" href="${h.url('/css/pygments.css')}"  />
     <link rel="stylesheet" type="text/css" href="${h.url('/css/diff.css')}"  />
     <link rel="stylesheet" type="text/css" href="${h.url('/css/style.css')}" media="screen"/>
 	<link rel="stylesheet" type="text/css" href="${h.url('/css/pygments.css')}"/>
     <link rel="stylesheet" type="text/css" href="${h.url('/css/diff.css')}"/>
     ${self.css_extra()}
 </%def>
 <%def name="css_extra()">
 </%def>
 <%def name="js()">
 	<script type="text/javascript">
 	  if (typeof console == "undefined" || typeof console.log == "undefined")
 	    console = { log: function() {} }
 	</script>
  % if False:
 	<script type="text/javascript" src="${h.url('/js/yui/utilities/utilities.js')}"></script>
 	<script type="text/javascript" src="${h.url('/js/yui/container/container.js')}"></script>
 	<script type="text/javascript" src="${h.url('/js/yui/datasource/datasource.js')}"></script>
 	<script type="text/javascript" src="${h.url('/js/yui/autocomplete/autocomplete.js')}"></script>
     <script type="text/javascript" src="${h.url('/js/yui/selector/selector-min.js')}"></script>
  % else:
 	<script type="text/javascript" src="${h.url('/js/yui2a.js')}"></script>
 	<!--[if IE]>
 	<script language="javascript" type="text/javascript" src="${h.url('/js/excanvas.min.js')}"></script>
 	<![endif]-->
 	<script type="text/javascript" src="${h.url('/js/yui.flot.js')}"></script>
  % endif
+   ${self.js_extra()}
 	<script type="text/javascript">
 		var YUC = YAHOO.util.Connect;
 		var YUD = YAHOO.util.Dom;
 		var YUE = YAHOO.util.Event;
 	</script>
 	<script type="text/javascript">
 	var base_url  = "${h.url('toggle_following')}";
 	function onSuccess(target){
 	    var f = YUD.get(target.id);
 	    var f_cnt = YUD.get('current_followers_count');
 	    if(f.getAttribute('class')=='follow'){
 	        f.setAttribute('class','following');
 	        f.setAttribute('title',"${_('Stop following this repository')}");
 	        if(f_cnt){
 	            var cnt = Number(f_cnt.innerHTML)+1;
 	            f_cnt.innerHTML = cnt;
+	        }
+	    }
 	    else{
 	        f.setAttribute('class','follow');
 	        f.setAttribute('title',"${_('Start following this repository')}");
 	        if(f_cnt){
 	            var cnt = Number(f_cnt.innerHTML)+1;
 	            f_cnt.innerHTML = cnt;
+	        }
+	    }
+	}
 	function toggleFollowingUser(target,fallows_user_id,token,user_id){
 	    args = 'follows_user_id='+fallows_user_id;
 	    args+= '&amp;auth_token='+token;
 	    if(user_id != undefined){
 	        args+="&amp;user_id="+user_id;
+	    }
 	    YUC.asyncRequest('POST',base_url,{
 	        success:function(o){
 	            onSuccess(target);
+	        }
 	    },args); return false;
+	}
 	function toggleFollowingRepo(target,fallows_repo_id,token,user_id){
 	    args = 'follows_repo_id='+fallows_repo_id;
 	    args+= '&amp;auth_token='+token;
 	    if(user_id != undefined){
 	        args+="&amp;user_id="+user_id;
+	    }
 	    YUC.asyncRequest('POST',base_url,{
 	        success:function(o){
 	            onSuccess(target);
+	        }
 	    },args); return false;
+	}
 	</script>
 </%def>
 <%def name="js_extra()">
 </%def>
@@ \ No newline at end of file @@

rhodecode/templates/files/files_annotate.html

➞

Show inline comments

 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${c.repo_name} ${_('File annotate')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('annotate')} @ R${c.cs.revision}:${h.short_id(c.cs.raw_id)}
 </%def>
 <%def name="page_nav()">
 		${self.menu('files')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
         <ul class="links">
             <li>
               <span style="text-transform: uppercase;"><a href="#">${_('branch')}: ${c.cs.branch}</a></span>
             </li>
         </ul>
     </div>
     <div class="table">
 		<div id="files_data">
 			<h3 class="files_location">${_('Location')}: ${h.files_breadcrumbs(c.repo_name,c.cs.revision,c.file.path)}</h3>
 			<dl class="overview">
 				<dt>${_('Revision')}</dt>
 				<dd>${h.link_to("r%s:%s" % (c.file.last_changeset.revision,h.short_id(c.file.last_changeset.raw_id)),
 						h.url('changeset_home',repo_name=c.repo_name,revision=c.file.last_changeset.raw_id))} </dd>
 				<dt>${_('Size')}</dt>
 				<dd>${h.format_byte_size(c.file.size,binary=True)}</dd>
     			<dt>${_('Mimetype')}</dt>
 				<dd>${c.file.mimetype}</dd>
 				<dt>${_('Options')}</dt>
 				<dd>${h.link_to(_('show source'),
 						h.url('files_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path))}
 					/ ${h.link_to(_('show as raw'),
 						h.url('files_raw_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path))}
 					/ ${h.link_to(_('download as raw'),
 						h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path))}
                     % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):
                     / ${h.link_to(_('edit'),
                         h.url('files_edit_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path))}
                     % endif
 				</dd>
 			    <dt>${_('History')}</dt>
 			    <dd>
 			        <div>
 			        ${h.form(h.url('files_diff_home',repo_name=c.repo_name,f_path=c.f_path),method='get')}
 			        ${h.hidden('diff2',c.file.last_changeset.raw_id)}
 			        ${h.select('diff1',c.file.last_changeset.raw_id,c.file_history)}
 			        ${h.submit('diff','diff to revision',class_="ui-button-small")}
 			        ${h.submit('show_rev','show at revision',class_="ui-button-small")}
 			        ${h.end_form()}
 			        </div>
 			    </dd>
 			</dl>
 			<div id="body" class="codeblock">
 				<div class="code-header">
 					<div class="revision">${c.file.name}@r${c.file.last_changeset.revision}:${h.short_id(c.file.last_changeset.raw_id)}</div>
 					<div class="commit">"${c.file.message}"</div>
 				</div>
 				<div class="code-body">
 			       %if c.file.is_binary:
 			           ${_('Binary file (%s)') % c.file.mimetype}
 			       %else:
 					% if c.file.size < c.cut_off_limit:
 						${h.pygmentize_annotation(c.repo_name,c.file,linenos=True,anchorlinenos=True,lineanchors='S',cssclass="code-highlight")}
 					%else:
 						${_('File is to big to display')} ${h.link_to(_('show as raw'),
 						h.url('files_raw_home',repo_name=c.repo_name,revision=c.cs.revision,f_path=c.f_path))}
 					%endif
 		            <script type="text/javascript">
 		            YAHOO.util.Event.onDOMReady(function(){
 		                YAHOO.util.Event.addListener('show_rev','click',function(e){
 		                    YAHOO.util.Event.preventDefault(e);
 		                    var cs = YAHOO.util.Dom.get('diff1').value;
 		                    var url = "${h.url('files_annotate_home',repo_name=c.repo_name,revision='__CS__',f_path=c.f_path)}".replace('__CS__',cs);
 		                    window.location = url;
 		                    });
 		               });
 		            </script>
 				   %endif
 				</div>
 			</div>
 		</div>
     </div>
 </div>
 </%def>
@@ \ No newline at end of file @@

rhodecode/templates/files/files_edit.html

➞

Show inline comments

@@ new file 100644 @@
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${c.repo_name} ${_('Edit file')} - ${c.rhodecode_name}
 </%def>
 <%def name="js_extra()">
 <script type="text/javascript" src="${h.url('/js/codemirror.js')}"></script>
 </%def>
 <%def name="css_extra()">
 <link rel="stylesheet" type="text/css" href="${h.url('/css/codemirror.css')}"/>
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('edit file')} @ R${c.cs.revision}:${h.short_id(c.cs.raw_id)}
 </%def>
 <%def name="page_nav()">
 		${self.menu('files')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
         <ul class="links">
             <li>
               <span style="text-transform: uppercase;">
               <a href="#">${_('branch')}: ${c.cs.branch}</a></span>
             </li>
         </ul>
     </div>
     <div class="table">
 		<div id="files_data">
 			<h3 class="files_location">${_('Location')}: ${h.files_breadcrumbs(c.repo_name,c.cs.revision,c.file.path)}</h3>
 			${h.form(h.url.current(),method='post',id='eform')}
 			<div id="body" class="codeblock">
 			    <pre id="editor_pre"></pre>
 				<textarea id="editor" name="content" style="display:none">${c.file.content|n}</textarea>
 				<div style="padding-top: 10px;">${_('commit message')}</div>
 				<textarea id="commit" name="message" style="height: 100px;width: 99%"></textarea>
 			</div>
 			<div style="text-align: right;padding-top: 5px">
 			<input id="reset" type="button" value="${_('Reset')}" class="ui-button-small" />
 			${h.submit('commit',_('Commit changes'),class_="ui-button-small-blue")}
 			</div>
 			${h.end_form()}
 			<script type="text/javascript">
 			 var myCodeMirror = CodeMirror.fromTextArea(YUD.get('editor'),{
 	                mode:  "null",
 	                lineNumbers:true
 	              });
 			 YUE.on('reset','click',function(){
 				 window.location="${h.url('files_home',repo_name=c.repo_name,revision=c.cs.revision,f_path=c.file.path)}";
 			 })
 			</script>
 		</div>
     </div>
 </div>
 </%def>
@@ \ No newline at end of file @@

rhodecode/templates/files/files_source.html

➞

Show inline comments

 <dl>
 	<dt>${_('Revision')}</dt>
 	<dd>
 		${h.link_to("r%s:%s" % (c.files_list.last_changeset.revision,h.short_id(c.files_list.last_changeset.raw_id)),
 						h.url('changeset_home',repo_name=c.repo_name,revision=c.files_list.last_changeset.raw_id))}
 	</dd>
 	<dt>${_('Size')}</dt>
 	<dd>${h.format_byte_size(c.files_list.size,binary=True)}</dd>
 	<dt>${_('Mimetype')}</dt>
 	<dd>${c.files_list.mimetype}</dd>
 	<dt>${_('Options')}</dt>
 	<dd>${h.link_to(_('show annotation'),
 			h.url('files_annotate_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path))}
 		 / ${h.link_to(_('show as raw'),
 			h.url('files_raw_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path))}
 		 / ${h.link_to(_('download as raw'),
 			h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path))}
         % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):
          / ${h.link_to(_('edit'),
             h.url('files_edit_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path))}
         % endif
 	</dd>
 	<dt>${_('History')}</dt>
 	<dd>
 		<div>
 		${h.form(h.url('files_diff_home',repo_name=c.repo_name,f_path=c.f_path),method='get')}
 		${h.hidden('diff2',c.files_list.last_changeset.raw_id)}
 		${h.select('diff1',c.files_list.last_changeset.raw_id,c.file_history)}
 		${h.submit('diff','diff to revision',class_="ui-button-small")}
 		${h.submit('show_rev','show at revision',class_="ui-button-small")}
 		${h.end_form()}
 		</div>
 	</dd>
 </dl>
 <div id="body" class="codeblock">
 	<div class="code-header">
 		<div class="revision">${c.files_list.name}@r${c.files_list.last_changeset.revision}:${h.short_id(c.files_list.last_changeset.raw_id)}</div>
 		<div class="commit">"${c.files_list.last_changeset.message}"</div>
 	</div>
 	<div class="code-body">
 	   %if c.files_list.is_binary:
 	       ${_('Binary file (%s)') % c.files_list.mimetype}
 	   %else:
 		% if c.files_list.size < c.cut_off_limit:
 			${h.pygmentize(c.files_list,linenos=True,anchorlinenos=True,lineanchors='L',cssclass="code-highlight")}
 		%else:
 			${_('File is to big to display')} ${h.link_to(_('show as raw'),
 			h.url('files_raw_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path))}
 		%endif
        <script type="text/javascript">
            function highlight_lines(lines){
                for(pos in lines){
                  YUD.setStyle('L'+lines[pos],'background-color','#FFFFBE');
+               }
+           }
            page_highlights = location.href.substring(location.href.indexOf('#')+1).split('L');
            if (page_highlights.length == 2){
               highlight_ranges  = page_highlights[1].split(",");
               var h_lines = [];
               for (pos in highlight_ranges){
                    var _range = highlight_ranges[pos].split('-');
                    if(_range.length == 2){
                        var start = parseInt(_range[0]);
                        var end = parseInt(_range[1]);
                        if (start < end){
                            for(var i=start;i<=end;i++){
                                h_lines.push(i);
+                           }
+                       }
+                   }
                    else{
                        h_lines.push(parseInt(highlight_ranges[pos]));
+                   }
+             }
            highlight_lines(h_lines);
+           }
        </script>
      %endif
 	</div>
 </div>
 <script type="text/javascript">
 YAHOO.util.Event.onDOMReady(function(){
     YAHOO.util.Event.addListener('show_rev','click',function(e){
     	YAHOO.util.Event.preventDefault(e);
         var cs = YAHOO.util.Dom.get('diff1').value;
         var url = "${h.url('files_home',repo_name=c.repo_name,revision='__CS__',f_path=c.f_path)}".replace('__CS__',cs);
         window.location = url;
         });
    });
 </script>
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)