Added codemirror syntax mode in gists.

- autopropose file extension when syntax mode is choosen

rhodecode/controllers/admin/gists.py

@@ -1,198 +1,199 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.gist
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     gist controller for RhodeCode
 
     :created_on: May 9, 2013
     :author: marcink
     :copyright: (C) 2010-2013 Marcin Kuzminski <[e-mail]>
     :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 time
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 
 from pylons import request, response, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.model.forms import GistForm
 from rhodecode.model.gist import GistModel
 from rhodecode.model.meta import Session
 from rhodecode.model.db import Gist
 from rhodecode.lib import helpers as h
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.auth import LoginRequired, NotAnonymous
 from rhodecode.lib.utils2 import safe_str, safe_int, time_to_datetime
 from rhodecode.lib.helpers import Page
 from webob.exc import HTTPNotFound, HTTPForbidden
 from sqlalchemy.sql.expression import or_
 from rhodecode.lib.vcs.exceptions import VCSError
 
 log = logging.getLogger(__name__)
 
 
 class GistsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
 
     def __load_defaults(self):
         c.lifetime_values = [
             (str(-1), _('forever')),
             (str(5), _('5 minutes')),
             (str(60), _('1 hour')),
             (str(60 * 24), _('1 day')),
             (str(60 * 24 * 30), _('1 month')),
         ]
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
 
     @LoginRequired()
     def index(self, format='html'):
         """GET /admin/gists: All items in the collection"""
         # url('gists')
         c.show_private = request.GET.get('private') and c.rhodecode_user.username != 'default'
         c.show_public = request.GET.get('public') and c.rhodecode_user.username != 'default'
 
         gists = Gist().query()\
             .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\
             .order_by(Gist.created_on.desc())
         if c.show_private:
             c.gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\
                              .filter(Gist.gist_owner == c.rhodecode_user.user_id)
         elif c.show_public:
             c.gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)\
                              .filter(Gist.gist_owner == c.rhodecode_user.user_id)
 
         else:
             c.gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
         p = safe_int(request.GET.get('page', 1), 1)
         c.gists_pager = Page(c.gists, page=p, items_per_page=10)
         return render('admin/gists/index.html')
 
     @LoginRequired()
     @NotAnonymous()
     def create(self):
         """POST /admin/gists: Create a new item"""
         # url('gists')
         self.__load_defaults()
         gist_form = GistForm([x[0] for x in c.lifetime_values])()
         try:
             form_result = gist_form.to_python(dict(request.POST))
             #TODO: multiple files support, from the form
+            filename = form_result['filename'] or 'gistfile1.txt'
             nodes = {
-                form_result['filename'] or 'gistfile1.txt': {
+                filename: {
                     'content': form_result['content'],
-                    'lexer': None  # autodetect
+                    'lexer': form_result['mimetype']  # None is autodetect
                 }
             }
             _public = form_result['public']
             gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE
             gist = GistModel().create(
                 description=form_result['description'],
                 owner=c.rhodecode_user,
                 gist_mapping=nodes,
                 gist_type=gist_type,
                 lifetime=form_result['lifetime']
             )
             Session().commit()
             new_gist_id = gist.gist_access_id
         except formencode.Invalid, errors:
             defaults = errors.value
 
             return formencode.htmlfill.render(
                 render('admin/gists/new.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8"
             )
 
         except Exception, e:
             log.error(traceback.format_exc())
             h.flash(_('Error occurred during gist creation'), category='error')
             return redirect(url('new_gist'))
         return redirect(url('gist', gist_id=new_gist_id))
 
     @LoginRequired()
     @NotAnonymous()
     def new(self, format='html'):
         """GET /admin/gists/new: Form to create a new item"""
         # url('new_gist')
         self.__load_defaults()
         return render('admin/gists/new.html')
 
     @LoginRequired()
     @NotAnonymous()
     def update(self, gist_id):
         """PUT /admin/gists/gist_id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('gist', gist_id=ID),
         #           method='put')
         # url('gist', gist_id=ID)
 
     @LoginRequired()
     @NotAnonymous()
     def delete(self, gist_id):
         """DELETE /admin/gists/gist_id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('gist', gist_id=ID),
         #           method='delete')
         # url('gist', gist_id=ID)
         gist = GistModel().get_gist(gist_id)
         owner = gist.gist_owner == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin')() or owner:
             GistModel().delete(gist)
             Session().commit()
             h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')
         else:
             raise HTTPForbidden()
 
         return redirect(url('gists'))
 
     @LoginRequired()
     def show(self, gist_id, format='html', revision='tip', f_path=None):
         """GET /admin/gists/gist_id: Show a specific item"""
         # url('gist', gist_id=ID)
         c.gist = Gist.get_or_404(gist_id)
 
         #check if this gist is not expired
         if c.gist.gist_expires != -1:
             if time.time() > c.gist.gist_expires:
                 log.error('Gist expired at %s' %
                           (time_to_datetime(c.gist.gist_expires)))
                 raise HTTPNotFound()
         try:
             c.file_changeset, c.files = GistModel().get_gist_files(gist_id)
         except VCSError:
             log.error(traceback.format_exc())
             raise HTTPNotFound()
         if format == 'raw':
             content = '\n\n'.join([f.content for f in c.files if (f_path is None or f.path == f_path)])
             response.content_type = 'text/plain'
             return content
         return render('admin/gists/show.html')
 
     @LoginRequired()
     @NotAnonymous()
     def edit(self, gist_id, format='html'):
         """GET /admin/gists/gist_id/edit: Form to edit an existing item"""
         # url('edit_gist', gist_id=ID)

rhodecode/model/forms.py

@@ -1,438 +1,439 b''
 """ this is forms validation classes
 http://formencode.org/module-formencode.validators.html
 for list off all availible validators
 
 we can create our own validators
 
 The table below outlines the options which can be used in a schema in addition to the validators themselves
 pre_validators          []     These validators will be applied before the schema
 chained_validators      []     These validators will be applied after the schema
 allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present
 filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed
 if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.
 ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already
 
 
 <name> = formencode.validators.<name of validator>
 <name> must equal form name
 list=[1,2,3,4,5]
 for SELECT use formencode.All(OneOf(list), Int())
 
 """
 import logging
 
 import formencode
 from formencode import All
 
 from pylons.i18n.translation import _
 
 from rhodecode.model import validators as v
 from rhodecode import BACKENDS
 
 log = logging.getLogger(__name__)
 
 
 class LoginForm(formencode.Schema):
     allow_extra_fields = True
     filter_extra_fields = True
     username = v.UnicodeString(
         strip=True,
         min=1,
         not_empty=True,
         messages={
            'empty': _(u'Please enter a login'),
            'tooShort': _(u'Enter a value %(min)i characters long or more')}
     )
 
     password = v.UnicodeString(
         strip=False,
         min=3,
         not_empty=True,
         messages={
             'empty': _(u'Please enter a password'),
             'tooShort': _(u'Enter %(min)i characters or more')}
     )
 
     remember = v.StringBoolean(if_missing=False)
 
     chained_validators = [v.ValidAuth()]
 
 
 def UserForm(edit=False, old_data={}):
     class _UserForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                        v.ValidUsername(edit, old_data))
         if edit:
             new_password = All(
                 v.ValidPassword(),
                 v.UnicodeString(strip=False, min=6, not_empty=False)
             )
             password_confirmation = All(
                 v.ValidPassword(),
                 v.UnicodeString(strip=False, min=6, not_empty=False),
             )
             admin = v.StringBoolean(if_missing=False)
         else:
             password = All(
                 v.ValidPassword(),
                 v.UnicodeString(strip=False, min=6, not_empty=True)
             )
             password_confirmation = All(
                 v.ValidPassword(),
                 v.UnicodeString(strip=False, min=6, not_empty=False)
             )
 
         active = v.StringBoolean(if_missing=False)
         firstname = v.UnicodeString(strip=True, min=1, not_empty=False)
         lastname = v.UnicodeString(strip=True, min=1, not_empty=False)
         email = All(v.Email(not_empty=True), v.UniqSystemEmail(old_data))
 
         chained_validators = [v.ValidPasswordsMatch()]
 
     return _UserForm
 
 
 def UserGroupForm(edit=False, old_data={}, available_members=[]):
     class _UserGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         users_group_name = All(
             v.UnicodeString(strip=True, min=1, not_empty=True),
             v.ValidUserGroup(edit, old_data)
         )
 
         users_group_active = v.StringBoolean(if_missing=False)
 
         if edit:
             users_group_members = v.OneOf(
                 available_members, hideList=False, testValueList=True,
                 if_missing=None, not_empty=False
             )
 
     return _UserGroupForm
 
 
 def ReposGroupForm(edit=False, old_data={}, available_groups=[],
                    can_create_in_root=False):
     class _ReposGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
 
         group_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                                v.SlugifyName())
         group_description = v.UnicodeString(strip=True, min=1,
                                                 not_empty=False)
         if edit:
             #FIXME: do a special check that we cannot move a group to one of
             #it's children
             pass
         group_parent_id = All(v.CanCreateGroup(can_create_in_root),
                               v.OneOf(available_groups, hideList=False,
                                       testValueList=True,
                                       if_missing=None, not_empty=True))
         enable_locking = v.StringBoolean(if_missing=False)
         chained_validators = [v.ValidReposGroup(edit, old_data)]
 
     return _ReposGroupForm
 
 
 def RegisterForm(edit=False, old_data={}):
     class _RegisterForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(
             v.ValidUsername(edit, old_data),
             v.UnicodeString(strip=True, min=1, not_empty=True)
         )
         password = All(
             v.ValidPassword(),
             v.UnicodeString(strip=False, min=6, not_empty=True)
         )
         password_confirmation = All(
             v.ValidPassword(),
             v.UnicodeString(strip=False, min=6, not_empty=True)
         )
         active = v.StringBoolean(if_missing=False)
         firstname = v.UnicodeString(strip=True, min=1, not_empty=False)
         lastname = v.UnicodeString(strip=True, min=1, not_empty=False)
         email = All(v.Email(not_empty=True), v.UniqSystemEmail(old_data))
 
         chained_validators = [v.ValidPasswordsMatch()]
 
     return _RegisterForm
 
 
 def PasswordResetForm():
     class _PasswordResetForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         email = All(v.ValidSystemEmail(), v.Email(not_empty=True))
     return _PasswordResetForm
 
 
 def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
              repo_groups=[], landing_revs=[]):
     class _RepoForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                         v.SlugifyName())
         repo_group = All(v.CanWriteGroup(old_data),
                          v.OneOf(repo_groups, hideList=True))
         repo_type = v.OneOf(supported_backends, required=False,
                             if_missing=old_data.get('repo_type'))
         repo_description = v.UnicodeString(strip=True, min=1, not_empty=False)
         repo_private = v.StringBoolean(if_missing=False)
         repo_landing_rev = v.OneOf(landing_revs, hideList=True)
         clone_uri = All(v.UnicodeString(strip=True, min=1, not_empty=False))
 
         repo_enable_statistics = v.StringBoolean(if_missing=False)
         repo_enable_downloads = v.StringBoolean(if_missing=False)
         repo_enable_locking = v.StringBoolean(if_missing=False)
 
         if edit:
             #this is repo owner
             user = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())
 
         chained_validators = [v.ValidCloneUri(),
                               v.ValidRepoName(edit, old_data)]
     return _RepoForm
 
 
 def RepoPermsForm():
     class _RepoPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         chained_validators = [v.ValidPerms(type_='repo')]
     return _RepoPermsForm
 
 
 def RepoGroupPermsForm():
     class _RepoGroupPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         recursive = v.StringBoolean(if_missing=False)
         chained_validators = [v.ValidPerms(type_='repo_group')]
     return _RepoGroupPermsForm
 
 
 def UserGroupPermsForm():
     class _UserPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         chained_validators = [v.ValidPerms(type_='user_group')]
     return _UserPermsForm
 
 
 def RepoFieldForm():
     class _RepoFieldForm(formencode.Schema):
         filter_extra_fields = True
         allow_extra_fields = True
 
         new_field_key = All(v.FieldKey(),
                             v.UnicodeString(strip=True, min=3, not_empty=True))
         new_field_value = v.UnicodeString(not_empty=False, if_missing='')
         new_field_type = v.OneOf(['str', 'unicode', 'list', 'tuple'],
                                  if_missing='str')
         new_field_label = v.UnicodeString(not_empty=False)
         new_field_desc = v.UnicodeString(not_empty=False)
 
     return _RepoFieldForm
 
 
 def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
                  repo_groups=[], landing_revs=[]):
     class _RepoForkForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                         v.SlugifyName())
         repo_group = All(v.CanWriteGroup(),
                          v.OneOf(repo_groups, hideList=True))
         repo_type = All(v.ValidForkType(old_data), v.OneOf(supported_backends))
         description = v.UnicodeString(strip=True, min=1, not_empty=True)
         private = v.StringBoolean(if_missing=False)
         copy_permissions = v.StringBoolean(if_missing=False)
         update_after_clone = v.StringBoolean(if_missing=False)
         fork_parent_id = v.UnicodeString()
         chained_validators = [v.ValidForkName(edit, old_data)]
         landing_rev = v.OneOf(landing_revs, hideList=True)
 
     return _RepoForkForm
 
 
 def ApplicationSettingsForm():
     class _ApplicationSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         rhodecode_title = v.UnicodeString(strip=True, min=1, not_empty=True)
         rhodecode_realm = v.UnicodeString(strip=True, min=1, not_empty=True)
         rhodecode_ga_code = v.UnicodeString(strip=True, min=1, not_empty=False)
 
     return _ApplicationSettingsForm
 
 
 def ApplicationVisualisationForm():
     class _ApplicationVisualisationForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         rhodecode_show_public_icon = v.StringBoolean(if_missing=False)
         rhodecode_show_private_icon = v.StringBoolean(if_missing=False)
         rhodecode_stylify_metatags = v.StringBoolean(if_missing=False)
 
         rhodecode_repository_fields = v.StringBoolean(if_missing=False)
         rhodecode_lightweight_journal = v.StringBoolean(if_missing=False)
         rhodecode_dashboard_items = v.Int(min=5, not_empty=True)
         rhodecode_show_version = v.StringBoolean(if_missing=False)
 
     return _ApplicationVisualisationForm
 
 
 def ApplicationUiSettingsForm():
     class _ApplicationUiSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         web_push_ssl = v.StringBoolean(if_missing=False)
         paths_root_path = All(
             v.ValidPath(),
             v.UnicodeString(strip=True, min=1, not_empty=True)
         )
         hooks_changegroup_update = v.StringBoolean(if_missing=False)
         hooks_changegroup_repo_size = v.StringBoolean(if_missing=False)
         hooks_changegroup_push_logger = v.StringBoolean(if_missing=False)
         hooks_outgoing_pull_logger = v.StringBoolean(if_missing=False)
 
         extensions_largefiles = v.StringBoolean(if_missing=False)
         extensions_hgsubversion = v.StringBoolean(if_missing=False)
         extensions_hggit = v.StringBoolean(if_missing=False)
 
     return _ApplicationUiSettingsForm
 
 
 def DefaultPermissionsForm(repo_perms_choices, group_perms_choices,
                            user_group_perms_choices, create_choices,
                            repo_group_create_choices, user_group_create_choices,
                            fork_choices, register_choices, extern_activate_choices):
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         overwrite_default_repo = v.StringBoolean(if_missing=False)
         overwrite_default_group = v.StringBoolean(if_missing=False)
         overwrite_default_user_group = v.StringBoolean(if_missing=False)
         anonymous = v.StringBoolean(if_missing=False)
         default_repo_perm = v.OneOf(repo_perms_choices)
         default_group_perm = v.OneOf(group_perms_choices)
         default_user_group_perm = v.OneOf(user_group_perms_choices)
 
         default_repo_create = v.OneOf(create_choices)
         default_user_group_create = v.OneOf(user_group_create_choices)
         #default_repo_group_create = v.OneOf(repo_group_create_choices) #not impl. yet
         default_fork = v.OneOf(fork_choices)
 
         default_register = v.OneOf(register_choices)
         default_extern_activate = v.OneOf(extern_activate_choices)
     return _DefaultPermissionsForm
 
 
 def CustomDefaultPermissionsForm():
     class _CustomDefaultPermissionsForm(formencode.Schema):
         filter_extra_fields = True
         allow_extra_fields = True
         inherit_default_permissions = v.StringBoolean(if_missing=False)
 
         create_repo_perm = v.StringBoolean(if_missing=False)
         create_user_group_perm = v.StringBoolean(if_missing=False)
         #create_repo_group_perm Impl. later
 
         fork_repo_perm = v.StringBoolean(if_missing=False)
 
     return _CustomDefaultPermissionsForm
 
 
 def DefaultsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):
     class _DefaultsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         default_repo_type = v.OneOf(supported_backends)
         default_repo_private = v.StringBoolean(if_missing=False)
         default_repo_enable_statistics = v.StringBoolean(if_missing=False)
         default_repo_enable_downloads = v.StringBoolean(if_missing=False)
         default_repo_enable_locking = v.StringBoolean(if_missing=False)
 
     return _DefaultsForm
 
 
 def LdapSettingsForm(tls_reqcert_choices, search_scope_choices,
                      tls_kind_choices):
     class _LdapSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         #pre_validators = [LdapLibValidator]
         ldap_active = v.StringBoolean(if_missing=False)
         ldap_host = v.UnicodeString(strip=True,)
         ldap_port = v.Number(strip=True,)
         ldap_tls_kind = v.OneOf(tls_kind_choices)
         ldap_tls_reqcert = v.OneOf(tls_reqcert_choices)
         ldap_dn_user = v.UnicodeString(strip=True,)
         ldap_dn_pass = v.UnicodeString(strip=True,)
         ldap_base_dn = v.UnicodeString(strip=True,)
         ldap_filter = v.UnicodeString(strip=True,)
         ldap_search_scope = v.OneOf(search_scope_choices)
         ldap_attr_login = v.AttrLoginValidator()(not_empty=True)
         ldap_attr_firstname = v.UnicodeString(strip=True,)
         ldap_attr_lastname = v.UnicodeString(strip=True,)
         ldap_attr_email = v.UnicodeString(strip=True,)
 
     return _LdapSettingsForm
 
 
 def UserExtraEmailForm():
     class _UserExtraEmailForm(formencode.Schema):
         email = All(v.UniqSystemEmail(), v.Email(not_empty=True))
     return _UserExtraEmailForm
 
 
 def UserExtraIpForm():
     class _UserExtraIpForm(formencode.Schema):
         ip = v.ValidIp()(not_empty=True)
     return _UserExtraIpForm
 
 
 def PullRequestForm(repo_id):
     class _PullRequestForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         user = v.UnicodeString(strip=True, required=True)
         org_repo = v.UnicodeString(strip=True, required=True)
         org_ref = v.UnicodeString(strip=True, required=True)
         other_repo = v.UnicodeString(strip=True, required=True)
         other_ref = v.UnicodeString(strip=True, required=True)
         revisions = All(#v.NotReviewedRevisions(repo_id)(),
                         v.UniqueList(not_empty=True))
         review_members = v.UniqueList(not_empty=True)
 
         pullrequest_title = v.UnicodeString(strip=True, required=True, min=3)
         pullrequest_desc = v.UnicodeString(strip=True, required=False)
 
         ancestor_rev = v.UnicodeString(strip=True, required=True)
         merge_rev = v.UnicodeString(strip=True, required=True)
 
     return _PullRequestForm
 
 
 def GistForm(lifetime_options):
     class _GistForm(formencode.Schema):
 
         filename = All(v.BasePath()(),
                        v.UnicodeString(strip=True, required=False))
         description = v.UnicodeString(required=False, if_missing='')
         lifetime = v.OneOf(lifetime_options)
+        mimetype = v.UnicodeString(required=False, if_missing=None)
         content = v.UnicodeString(required=True, not_empty=True)
         public = v.UnicodeString(required=False, if_missing='')
         private = v.UnicodeString(required=False, if_missing='')
 
     return _GistForm

rhodecode/public/js/mode/meta.js

@@ -1,77 +1,305 b''
 CodeMirror.modeInfo = [
   {name: 'APL', mime: 'text/apl', mode: 'apl'},
   {name: 'Asterisk', mime: 'text/x-asterisk', mode: 'asterisk'},
   {name: 'C', mime: 'text/x-csrc', mode: 'clike'},
   {name: 'C++', mime: 'text/x-c++src', mode: 'clike'},
   {name: 'Cobol', mime: 'text/x-cobol', mode: 'cobol'},
   {name: 'Java', mime: 'text/x-java', mode: 'clike'},
   {name: 'C#', mime: 'text/x-csharp', mode: 'clike'},
   {name: 'Scala', mime: 'text/x-scala', mode: 'clike'},
   {name: 'Clojure', mime: 'text/x-clojure', mode: 'clojure'},
   {name: 'CoffeeScript', mime: 'text/x-coffeescript', mode: 'coffeescript'},
   {name: 'Common Lisp', mime: 'text/x-common-lisp', mode: 'commonlisp'},
   {name: 'CSS', mime: 'text/css', mode: 'css'},
   {name: 'D', mime: 'text/x-d', mode: 'd'},
   {name: 'diff', mime: 'text/x-diff', mode: 'diff'},
   {name: 'ECL', mime: 'text/x-ecl', mode: 'ecl'},
   {name: 'Erlang', mime: 'text/x-erlang', mode: 'erlang'},
   {name: 'Gas', mime: 'text/x-gas', mode: 'gas'},
-  {name: 'GitHub Flavored Markdown', mode: 'gfm'},
   {name: 'GO', mime: 'text/x-go', mode: 'go'},
   {name: 'Groovy', mime: 'text/x-groovy', mode: 'groovy'},
   {name: 'Haskell', mime: 'text/x-haskell', mode: 'haskell'},
   {name: 'Haxe', mime: 'text/x-haxe', mode: 'haxe'},
   {name: 'ASP.NET', mime: 'application/x-aspx', mode: 'htmlembedded'},
   {name: 'Embedded Javascript', mime: 'application/x-ejs', mode: 'htmlembedded'},
   {name: 'JavaServer Pages', mime: 'application/x-jsp', mode: 'htmlembedded'},
   {name: 'HTML', mime: 'text/html', mode: 'htmlmixed'},
   {name: 'HTTP', mime: 'message/http', mode: 'http'},
   {name: 'JavaScript', mime: 'text/javascript', mode: 'javascript'},
   {name: 'JSON', mime: 'application/x-json', mode: 'javascript'},
   {name: 'JSON', mime: 'application/json', mode: 'javascript'},
   {name: 'TypeScript', mime: 'application/typescript', mode: 'javascript'},
   {name: 'Jinja2', mime: 'jinja2', mode: 'jinja2'},
   {name: 'LESS', mime: 'text/x-less', mode: 'less'},
   {name: 'LiveScript', mime: 'text/x-livescript', mode: 'livescript'},
   {name: 'Lua', mime: 'text/x-lua', mode: 'lua'},
   {name: 'Markdown (GitHub-flavour)', mime: 'text/x-markdown', mode: 'markdown'},
   {name: 'mIRC', mime: 'text/mirc', mode: 'mirc'},
   {name: 'NTriples', mime: 'text/n-triples', mode: 'ntriples'},
   {name: 'OCaml', mime: 'text/x-ocaml', mode: 'ocaml'},
   {name: 'Pascal', mime: 'text/x-pascal', mode: 'pascal'},
   {name: 'Perl', mime: 'text/x-perl', mode: 'perl'},
   {name: 'PHP', mime: 'text/x-php', mode: 'php'},
   {name: 'PHP(HTML)', mime: 'application/x-httpd-php', mode: 'php'},
   {name: 'Pig', mime: 'text/x-pig', mode: 'pig'},
   {name: 'Plain Text', mime: 'text/plain', mode: 'null'},
   {name: 'Properties files', mime: 'text/x-properties', mode: 'clike'},
   {name: 'Python', mime: 'text/x-python', mode: 'python'},
   {name: 'R', mime: 'text/x-rsrc', mode: 'r'},
   {name: 'reStructuredText', mime: 'text/x-rst', mode: 'rst'},
   {name: 'Ruby', mime: 'text/x-ruby', mode: 'ruby'},
   {name: 'Rust', mime: 'text/x-rustsrc', mode: 'rust'},
   {name: 'Sass', mime: 'text/x-sass', mode: 'sass'},
   {name: 'Scheme', mime: 'text/x-scheme', mode: 'scheme'},
   {name: 'SCSS', mime: 'text/x-scss', mode: 'css'},
   {name: 'Shell', mime: 'text/x-sh', mode: 'shell'},
   {name: 'Sieve', mime: 'application/sieve', mode: 'sieve'},
   {name: 'Smalltalk', mime: 'text/x-stsrc', mode: 'smalltalk'},
   {name: 'Smarty', mime: 'text/x-smarty', mode: 'smarty'},
   {name: 'SPARQL', mime: 'application/x-sparql-query', mode: 'sparql'},
   {name: 'SQL', mime: 'text/x-sql', mode: 'sql'},
   {name: 'MariaDB', mime: 'text/x-mariadb', mode: 'sql'},
   {name: 'sTeX', mime: 'text/x-stex', mode: 'stex'},
   {name: 'LaTeX', mime: 'text/x-latex', mode: 'stex'},
   {name: 'Tcl', mime: 'text/x-tcl', mode: 'tcl'},
   {name: 'TiddlyWiki ', mime: 'text/x-tiddlywiki', mode: 'tiddlywiki'},
   {name: 'Tiki wiki', mime: 'text/tiki', mode: 'tiki'},
   {name: 'VB.NET', mime: 'text/x-vb', mode: 'vb'},
   {name: 'VBScript', mime: 'text/vbscript', mode: 'vbscript'},
   {name: 'Velocity', mime: 'text/velocity', mode: 'velocity'},
   {name: 'Verilog', mime: 'text/x-verilog', mode: 'verilog'},
   {name: 'XML', mime: 'application/xml', mode: 'xml'},
   {name: 'HTML', mime: 'text/html', mode: 'xml'},
   {name: 'XQuery', mime: 'application/xquery', mode: 'xquery'},
   {name: 'YAML', mime: 'text/x-yaml', mode: 'yaml'},
   {name: 'Z80', mime: 'text/x-z80', mode: 'z80'}
 ];
+
+
+MIME_TO_EXT = {
+    'application/javascript': ['*.js'],
+    'text/javascript': ['*.js'],
+    'application/json': ['*.json'],
+    'application/postscript': ['*.ps', '*.eps'],
+    'application/x-actionscript': ['*.as'],
+    'application/x-actionscript3': ['*.as'],
+    'application/x-awk': ['*.awk'],
+    'application/x-befunge': ['*.befunge'],
+    'application/x-brainfuck': ['*.bf', '*.b'],
+    'application/x-cheetah': ['*.tmpl', '*.spt'],
+    'application/x-coldfusion': ['*.cfm', '*.cfml', '*.cfc'],
+    'application/x-csh': ['*.tcsh', '*.csh'],
+    'application/x-dos-batch': ['*.bat', '*.cmd'],
+    'application/x-ecl': ['*.ecl'],
+    'application/x-evoque': ['*.evoque'],
+    'application/x-fantom': ['*.fan'],
+    'application/x-genshi': ['*.kid'],
+    'application/x-gettext': ['*.pot', '*.po'],
+    'application/x-jsp': ['*.jsp'],
+    'application/x-mako': ['*.mao'],
+    'application/x-mason': ['*.m', '*.mhtml', '*.mc', '*.mi', 'autohandler', 'dhandler'],
+    'application/x-myghty': ['*.myt', 'autodelegate'],
+    'application/x-php': ['*.phtml'],
+    'application/x-pypylog': ['*.pypylog'],
+    'application/x-qml': ['*.qml'],
+    'application/x-sh': ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '.bashrc', 'bashrc', '.bash_*', 'bash_*'],
+    'application/x-sh-session': ['*.shell-session'],
+    'application/x-shell-session': ['*.sh-session'],
+    'application/x-smarty': ['*.tpl'],
+    'application/x-ssp': ['*.ssp'],
+    'application/x-troff': ['*.[1234567]', '*.man'],
+    'application/x-urbiscript': ['*.u'],
+    'application/xml+evoque': ['*.xml'],
+    'application/xml-dtd': ['*.dtd'],
+    'application/xsl+xml': ['*.xsl', '*.xslt', '*.xpl'],
+    'text/S-plus': ['*.S', '*.R', '.Rhistory', '.Rprofile'],
+    'text/coffeescript': ['*.coffee'],
+    'text/css': ['*.css'],
+    'text/haxe': ['*.hx'],
+    'text/html': ['*.html', '*.htm', '*.xhtml', '*.xslt'],
+    'text/html+evoque': ['*.html'],
+    'text/html+ruby': ['*.rhtml'],
+    'text/idl': ['*.pro'],
+    'text/livescript': ['*.ls'],
+    'text/matlab': ['*.m'],
+    'text/octave': ['*.m'],
+    'text/plain': ['*.txt'],
+    'text/scilab': ['*.sci', '*.sce', '*.tst'],
+    'text/smali': ['*.smali'],
+    'text/x-abap': ['*.abap'],
+    'text/x-ada': ['*.adb', '*.ads', '*.ada'],
+    'text/x-apacheconf': ['.htaccess', 'apache.conf', 'apache2.conf'],
+    'text/x-aspectj': ['*.aj'],
+    'text/x-asymptote': ['*.asy'],
+    'text/x-autohotkey': ['*.ahk', '*.ahkl'],
+    'text/x-autoit': ['*.au3'],
+    'text/x-bmx': ['*.bmx'],
+    'text/x-boo': ['*.boo'],
+    'text/x-c++hdr': ['*.cpp', '*.hpp', '*.c++', '*.h++', '*.cc', '*.hh', '*.cxx', '*.hxx', '*.C', '*.H', '*.cp','*.CPP'],
+    'text/x-c-objdump': ['*.c-objdump'],
+    'text/x-ceylon': ['*.ceylon'],
+    'text/x-chdr': ['*.c', '*.h', '*.idc'],
+    'text/x-clojure': ['*.clj'],
+    'text/x-cmake': ['*.cmake', 'CMakeLists.txt'],
+    'text/x-cobol': ['*.cob', '*.COB', '*.cpy', '*.CPY'],
+    'text/x-common-lisp': ['*.cl', '*.lisp', '*.el'],
+    'text/x-coq': ['*.v'],
+    'text/x-cpp-objdump': ['*.cpp-objdump', '*.c++-objdump', '*.cxx-objdump'],
+    'text/x-crocsrc': ['*.croc'],
+    'text/x-csharp': ['*.cs'],
+    'text/x-cuda': ['*.cu', '*.cuh'],
+    'text/x-cython': ['*.pyx', '*.pxd', '*.pxi'],
+    'text/x-d-objdump': ['*.d-objdump'],
+    'text/x-dart': ['*.dart'],
+    'text/x-dg': ['*.dg'],
+    'text/x-diff': ['*.diff', '*.patch'],
+    'text/x-dsrc': ['*.d', '*.di'],
+    'text/x-duel': ['*.duel', '*.jbst'],
+    'text/x-dylan': ['*.dylan', '*.dyl', '*.intr'],
+    'text/x-dylan-console': ['*.dylan-console'],
+    'text/x-dylan-lid': ['*.lid', '*.hdp'],
+    'text/x-echdr': ['*.ec', '*.eh'],
+    'text/x-elixir': ['*.ex', '*.exs'],
+    'text/x-erl-shellsession': ['*.erl-sh'],
+    'text/x-erlang': ['*.erl', '*.hrl', '*.es', '*.escript'],
+    'text/x-factor': ['*.factor'],
+    'text/x-fancysrc': ['*.fy', '*.fancypack'],
+    'text/x-felix': ['*.flx', '*.flxh'],
+    'text/x-fortran': ['*.f', '*.f90', '*.F', '*.F90'],
+    'text/x-fsharp': ['*.fs', '*.fsi'],
+    'text/x-gas': ['*.s', '*.S'],
+    'text/x-gherkin': ['*.feature'],
+    'text/x-glslsrc': ['*.vert', '*.frag', '*.geo'],
+    'text/x-gnuplot': ['*.plot', '*.plt'],
+    'text/x-gooddata-cl': ['*.gdc'],
+    'text/x-gooddata-maql': ['*.maql'],
+    'text/x-gosrc': ['*.go'],
+    'text/x-gosu': ['*.gs', '*.gsx', '*.gsp', '*.vark'],
+    'text/x-gosu-template': ['*.gst'],
+    'text/x-groovy': ['*.groovy'],
+    'text/x-haml': ['*.haml'],
+    'text/x-haskell': ['*.hs'],
+    'text/x-hybris': ['*.hy', '*.hyb'],
+    'text/x-ini': ['*.ini', '*.cfg'],
+    'text/x-iokesrc': ['*.ik'],
+    'text/x-iosrc': ['*.io'],
+    'text/x-irclog': ['*.weechatlog'],
+    'text/x-jade': ['*.jade'],
+    'text/x-java': ['*.java'],
+    'text/x-java-properties': ['*.properties'],
+    'text/x-julia': ['*.jl'],
+    'text/x-kconfig': ['Kconfig', '*Config.in*', 'external.in*', 'standard-modules.in'],
+    'text/x-koka': ['*.kk', '*.kki'],
+    'text/x-kotlin': ['*.kt'],
+    'text/x-lasso': ['*.lasso', '*.lasso[89]'],
+    'text/x-literate-haskell': ['*.lhs'],
+    'text/x-llvm': ['*.ll'],
+    'text/x-logos': ['*.x', '*.xi', '*.xm', '*.xmi'],
+    'text/x-logtalk': ['*.lgt'],
+    'text/x-lua': ['*.lua', '*.wlua'],
+    'text/x-makefile': ['*.mak', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'],
+    'text/x-minidsrc': ['*.md'],
+    'text/x-markdown': ['*.md'],
+    'text/x-modelica': ['*.mo'],
+    'text/x-modula2': ['*.def', '*.mod'],
+    'text/x-monkey': ['*.monkey'],
+    'text/x-moocode': ['*.moo'],
+    'text/x-moonscript': ['*.moon'],
+    'text/x-nasm': ['*.asm', '*.ASM'],
+    'text/x-nemerle': ['*.n'],
+    'text/x-newlisp': ['*.lsp', '*.nl'],
+    'text/x-newspeak': ['*.ns2'],
+    'text/x-nimrod': ['*.nim', '*.nimrod'],
+    'text/x-nsis': ['*.nsi', '*.nsh'],
+    'text/x-objdump': ['*.objdump'],
+    'text/x-objective-c': ['*.m', '*.h'],
+    'text/x-objective-c++': ['*.mm', '*.hh'],
+    'text/x-objective-j': ['*.j'],
+    'text/x-ocaml': ['*.ml', '*.mli', '*.mll', '*.mly'],
+    'text/x-ooc': ['*.ooc'],
+    'text/x-opa': ['*.opa'],
+    'text/x-openedge': ['*.p', '*.cls'],
+    'text/x-pascal': ['*.pas'],
+    'text/x-perl': ['*.pl', '*.pm'],
+    'text/x-php': ['*.php', '*.php[345]', '*.inc'],
+    'text/x-povray': ['*.pov', '*.inc'],
+    'text/x-powershell': ['*.ps1'],
+    'text/x-prolog': ['*.prolog', '*.pro', '*.pl'],
+    'text/x-python': ['*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac', '*.sage'],
+    'text/x-python-traceback': ['*.pytb'],
+    'text/x-python3-traceback': ['*.py3tb'],
+    'text/x-r-doc': ['*.Rd'],
+    'text/x-racket': ['*.rkt', '*.rktl'],
+    'text/x-rebol': ['*.r', '*.r3'],
+    'text/x-robotframework': ['*.txt', '*.robot'],
+    'text/x-rpm-spec': ['*.spec'],
+    'text/x-rst': ['*.rst', '*.rest'],
+    'text/x-ruby': ['*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec', '*.rbx', '*.duby'],
+    'text/x-rustsrc': ['*.rs', '*.rc'],
+    'text/x-sass': ['*.sass'],
+    'text/x-scala': ['*.scala'],
+    'text/x-scaml': ['*.scaml'],
+    'text/x-scheme': ['*.scm', '*.ss'],
+    'text/x-scss': ['*.scss'],
+    'text/x-smalltalk': ['*.st'],
+    'text/x-snobol': ['*.snobol'],
+    'text/x-sourcepawn': ['*.sp'],
+    'text/x-sql': ['*.sql'],
+    'text/x-sqlite3-console': ['*.sqlite3-console'],
+    'text/x-squidconf': ['squid.conf'],
+    'text/x-standardml': ['*.sml', '*.sig', '*.fun'],
+    'text/x-systemverilog': ['*.sv', '*.svh'],
+    'text/x-tcl': ['*.tcl'],
+    'text/x-tea': ['*.tea'],
+    'text/x-tex': ['*.tex', '*.aux', '*.toc'],
+    'text/x-typescript': ['*.ts'],
+    'text/x-vala': ['*.vala', '*.vapi'],
+    'text/x-vbnet': ['*.vb', '*.bas'],
+    'text/x-verilog': ['*.v'],
+    'text/x-vhdl': ['*.vhdl', '*.vhd'],
+    'text/x-vim': ['*.vim', '.vimrc', '.exrc', '.gvimrc', '_vimrc', '_exrc', '_gvimrc', 'vimrc', 'gvimrc'],
+    'text/x-windows-registry': ['*.reg'],
+    'text/x-xtend': ['*.xtend'],
+    'text/x-yaml': ['*.yaml', '*.yml'],
+    'text/xml': ['*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl'],
+    'text/xquery': ['*.xqy', '*.xquery', '*.xq', '*.xql', '*.xqm'],
+    'text/apl': [],
+    'text/x-asterisk': [],
+    'text/x-csrc': [],
+    'text/x-c++src': ['*.cpp'],
+    'text/x-coffeescript': ['*.coffee'],
+    'text/x-d': ["*.d"],
+    'text/x-ecl': ['*.ecl'],
+    'text/x-go': ['*.go'],
+    'text/x-haxe': ['*.hx'],
+    'application/x-aspx': ['*.aspx'],
+    'application/x-ejs': [],
+    'message/http': [],
+    'application/x-json': ['*.json'],
+    'application/typescript': ['*.ts'],
+    'jinja2': ['.jinja2'],
+    'text/x-less': ['*.less'],
+    'text/x-livescript': ['*.ls'],
+    'text/mirc': [],
+    'text/n-triples': [],
+    'application/x-httpd-php': ['*.php'],
+    'text/x-pig': [],
+    'text/x-properties': ['*.properties'],
+    'text/x-rsrc': [],
+    'text/x-sh': ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '.bashrc', 'bashrc', '.bash_*', 'bash_*'],
+    'application/sieve': [],
+    'text/x-stsrc': ['*.rs', '*.rc'],
+    'text/x-smarty': ['*.tpl'],
+    'application/x-sparql-query': [],
+    'text/x-mariadb': ['*.sql'],
+    'text/x-stex': [],
+    'text/x-latex': ["*.ltx"],
+    'text/x-tiddlywiki': [],
+    'text/tiki': [],
+    'text/x-vb': ['*.vb'],
+    'text/vbscript': ['*.vb'],
+    'text/velocity': [],
+    'application/xml': ['*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl'],
+    'application/xquery': ['*.xqy', '*.xquery', '*.xq', '*.xql', '*.xqm'],
+    'text/x-z80': [],
+}

rhodecode/templates/admin/gists/new.html

@@ -1,81 +1,98 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('New gist')} &middot; ${c.rhodecode_name}
 </%def>
 
 <%def name="js_extra()">
 <script type="text/javascript" src="${h.url('/js/codemirror.js')}"></script>
 <script type="text/javascript" src="${h.url('/js/codemirror_loadmode.js')}"></script>
 <script type="text/javascript" src="${h.url('/js/mode/meta.js')}"></script>
 </%def>
 <%def name="css_extra()">
 <link rel="stylesheet" type="text/css" href="${h.url('/css/codemirror.css')}"/>
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('New gist')}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('gists')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     <div class="table">
         <div id="files_data">
           ${h.form(h.url('gists'), method='post',id='eform')}
             <div>
                 <div class="gravatar">
                    <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(c.rhodecode_user.full_contact),32)}"/>
                 </div>
                 <textarea style="resize:vertical; width:400px;border: 1px solid #ccc;border-radius: 3px;" id="description" name="description" placeholder="${_('Gist description ...')}"></textarea>
+                <div style="padding:0px 0px 0px 42px">
+                <label for='lifetime'>${_('Gist lifetime')}</label>
+                ${h.select('lifetime', '', c.lifetime_options)}
+                </div>
             </div>
             <div id="body" class="codeblock">
                 <div style="padding: 10px 10px 10px 26px;color:#666666">
                     ##<input type="text" value="" size="30" name="filename" id="filename" placeholder="gistfile1.txt">
                     ${h.text('filename', size=30, placeholder='gistfile1.txt')}
                     ##<input type="text" value="" size="30" name="filename" id="filename" placeholder="gistfile1.txt">
-                    ${h.select('lifetime', '', c.lifetime_options)}
-                    ${h.select('set_mode','plain',[('plain',_('plain'))])}
+                    ${h.select('mimetype','plain',[('plain',_('plain'))])}
                 </div>
                 <div id="editor_container">
                     <pre id="editor_pre"></pre>
                     <textarea id="editor" name="content" style="display:none"></textarea>
                 </div>
             </div>
             <div style="padding-top: 5px">
             ${h.submit('private',_('Create private gist'),class_="ui-btn yellow")}
             ${h.submit('public',_('Create public gist'),class_="ui-btn")}
             ${h.reset('reset',_('Reset'),class_="ui-btn")}
             </div>
             ${h.end_form()}
             <script type="text/javascript">
             var myCodeMirror = initCodeMirror('editor', '');
             CodeMirror.modeURL = "${h.url('/js/mode/%N/%N.js')}";
 
             //inject new modes
-            var modes_select = YUD.get('set_mode');
+            var modes_select = YUD.get('mimetype');
             for(var i=0;i<CodeMirror.modeInfo.length;i++){
                 var m = CodeMirror.modeInfo[i];
-                var opt = new Option(m.name, m.mode);
-                modes_select.options[i+1] = opt
+                var opt = new Option(m.name, m.mime);
+                YUD.setAttribute(opt, 'mode', m.mode)
+                modes_select.options[i+1] = opt;
             }
             YUE.on(modes_select, 'change', function(e){
                 var selected = e.currentTarget;
-                var new_mode = selected.options[selected.selectedIndex].value;
+                var node = selected.options[selected.selectedIndex];
+                var mimetype = node.value;
+                var new_mode = YUD.getAttribute(node, 'mode')
                 setCodeMirrorMode(myCodeMirror, new_mode);
+
+                var proposed_mimetypes = MIME_TO_EXT[mimetype] || [];
+                if(proposed_mimetypes.length < 1){
+                    //fallback to text/plain
+                    proposed_mimetypes = ['.txt']
+                }
+                var mt = proposed_mimetypes[0];
+                if(mt[0] == '*'){
+                    mt = mt.substr(1)
+                }
+                YUD.get('filename').value = 'filename1' + mt;
             })
             </script>
         </div>
     </div>
 
 </div>
 </%def>