# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.bin.base

~~~~~~~~~~~~~~~~~~

Base utils for shell scripts

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 09, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

import random

import urllib2

import pprint

from kallithea.lib.compat import json

CONFIG_NAME = '.config/kallithea'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

def api_call(apikey, apihost, method=None, **kw):

    """

    Api_call wrapper for Kallithea.

    :param apikey:

    :param apihost:

    :param format: formatting, pretty means prints and pprint of json

     json returns unparsed json

    :param method:

    :returns: json response from server

    """

    def _build_data(random_id):

        """

        Builds API data with given random ID

        :param random_id:

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    apihost = apihost.rstrip('/')

    id_ = random.randrange(1, 9999)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      data=json.dumps(_build_data(id_)),

                      headers={'content-type': 'text/plain'})

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    json_data = json.loads(raw_json)

    id_ret = json_data['id']

    if id_ret == id_:

        return json_data

    else:

        _formatted_json = pprint.pformat(json_data)

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

class RcConf(object):

    """

    Kallithea config for API

    conf = RcConf()

    conf['key']

    """

    def __init__(self, config_location=None, autoload=True, autocreate=False,

                 config=None):

        HOME = os.getenv('HOME', os.getenv('USERPROFILE')) or ''

        HOME_CONF = os.path.abspath(os.path.join(HOME, CONFIG_NAME))

        self._conf_name = HOME_CONF if not config_location else config_location

        self._conf = {}

        if autocreate:

            self.make_config(config)

        if autoload:

            self._conf = self.load_config()

    def __getitem__(self, key):

        return self._conf[key]

    def __nonzero__(self):

        if self._conf:

            return True

        return False

    def __eq__(self):

        return self._conf.__eq__()

    def __repr__(self):

        return 'RcConf<%s>' % self._conf.__repr__()

    def make_config(self, config):

        """

        Saves given config as a JSON dump in the _conf_name location

        :param config:

        """

        update = False

        if os.path.exists(self._conf_name):

            update = True

        with open(self._conf_name, 'wb') as f:

            json.dump(config, f, indent=4)

            f.write('\n')

        if update:

            sys.stdout.write('Updated config in %s\n' % self._conf_name)

        else:

            sys.stdout.write('Created new config in %s\n' % self._conf_name)

    def update_config(self, new_config):

        """

        Reads the JSON config updates it's values with new_config and

        saves it back as JSON dump

        :param new_config:

        """

        config = {}

        try:

            with open(self._conf_name, 'rb') as conf:

                config = json.load(conf)

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        self.make_config(config)

    def load_config(self):

        """

        Loads config from file and returns loaded JSON object

        """

        try:

            with open(self._conf_name, 'rb') as conf:

                return  json.load(conf)

            #sys.stderr.write(str(e) + '\n')

            pass

# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.bin.kallithea_gist

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Gist CLI client for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

from __future__ import with_statement

import os

import sys

import stat

import argparse

import fileinput

from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

def argparser(argv):

    usage = (

      "kallithea-gist [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] [GIST OPTIONS] "

      "[filename or stdin use - for terminal stdin ]\n"

      "Create config file: kallithea-gist --apikey=<key> --apihost=http://your.kallithea.server --save-config"

    )

    parser = argparse.ArgumentParser(description='Kallithea Gist cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group.add_argument('--config', help='config file path DEFAULT: ~/.config/kallithea')

    group.add_argument('--save-config', action='store_true',

                       help='save the given config into a file')

    group = parser.add_argument_group('GIST')

    group.add_argument('-p', '--private', action='store_true',

                       help='create private Gist')

    group.add_argument('-f', '--filename',

                       help='set uploaded gist filename, '

                            'also defines syntax highlighting')

    group.add_argument('-d', '--description', help='Gist description')

    group.add_argument('-l', '--lifetime', metavar='MINUTES',

                       help='gist lifetime in minutes, -1 (DEFAULT) is forever')

    group.add_argument('--format', dest='format', type=str,

                       help='output format DEFAULT: `%s` can '

                       'be also `%s`' % (FORMAT_PRETTY, FORMAT_JSON),

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def _run(argv):

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.save_config:

        if not api_credentials_given:

            raise parser.error('--save-config requires --apikey and --apihost')

        conf = RcConf(config_location=args.config,

                      autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.exit()

    if not conf:

        conf = RcConf(config_location=args.config, autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    DEFAULT_FILENAME = 'gistfile1.txt'

    if other:

        # skip multifiles for now

        filename = other[0]

        if filename == '-':

            filename = DEFAULT_FILENAME

            gist_content = ''

            for line in fileinput.input('-'):

                gist_content += line

        else:

            with open(filename, 'rb') as f:

                gist_content = f.read()

    else:

        filename = DEFAULT_FILENAME

        gist_content = None

        # little bit hacky but cross platform check where the

        # stdin comes from we skip the terminal case it can be handled by '-'

        mode = os.fstat(0).st_mode

        if stat.S_ISFIFO(mode):

            # "stdin is piped"

            gist_content = sys.stdin.read()

        elif stat.S_ISREG(mode):

            # "stdin is redirected"

            gist_content = sys.stdin.read()

        else:

            # "stdin is terminal"

            pass

    # make sure we don't upload binary stuff

    if gist_content and '\0' in gist_content:

        raise Exception('Error: binary files upload is not possible')

    filename = os.path.basename(args.filename or filename)

    if gist_content:

        files = {

            filename: {

                'content': gist_content,

                'lexer': None

            }

        }

        margs = dict(

            lifetime=args.lifetime,

            description=args.description,

            gist_type='private' if args.private else 'public',

            files=files

        )

        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

        if args.format == FORMAT_JSON:

            print json.dumps(json_data)

        elif args.format == FORMAT_PRETTY:

            print json_data

            print 'Created %s gist %s' % (json_data['gist']['type'],

                                          json_data['gist']['url'])

    return 0

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

    try:

        return _run(argv)

        print e

        return 1

if __name__ == '__main__':

    sys.exit(main(sys.argv))

#!/usr/bin/env python2

# 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/>.

"""

Script for rebranding of database to and from what Kallithea expects

Works on databases from v1.7.2 to v2.2.5

"""

import sys

from sqlalchemy import *

import sqlalchemy.orm

import sqlalchemy.ext.declarative

import migrate.changeset # a part of sqlalchemy-migrate which is available on pypi

def do_migrate(db, old, new):

    print 'Migrating %s from %s to %s' % (db, old or '?', new)

    metadata = MetaData()

    metadata.bind = create_engine(db)

    metadata.reflect()

    assert metadata.tables, 'Cannot reflect table names from db'

    if not old:

        assert 'db_migrate_version' in metadata.tables, 'Cannot reflect db_migrate_version from db'

        t = metadata.tables['db_migrate_version']

        l = t.select().where(t.c.repository_path == 'versions').execute().fetchall()

        assert len(l) == 1, 'Cannot find a single versions entry in db_migrate_version'

        assert l[0].repository_id.endswith('_db_migrations')

        old = l[0].repository_id[:-len('_db_migrations')]

        print 'Detected migration from old name %s' % old

        if new != old:

            assert not t.select().where(t.c.repository_id == new + '_db_migrations').execute().fetchall(), 'db_migrate_version has entries for both old and new name'

    def tablename(brand, s):

        return s if brand == 'kallithea' else (brand + '_' + s)

    new_ui_name = tablename(new, 'ui')

    old_ui_name = tablename(old, 'ui')

    new_settings_name = tablename(new, 'settings')

    old_settings_name = tablename(old, 'settings')

    # Table renames using sqlalchemy-migrate (available on pypi)

    if new_ui_name == old_ui_name:

        print 'No renaming of %s' % new_ui_name

    else:

        try:

            t = metadata.tables[old_ui_name]

            print 'Renaming', t, 'to', new_ui_name

            migrate.changeset.rename_table(t, new_ui_name)

            print 'Not renaming ui:', e

    if new_settings_name == old_settings_name:

        print 'No renaming of %s' % new_settings_name

    else:

        try:

            t = metadata.tables[old_settings_name]

            print 'Renaming', t, 'to', new_settings_name

            migrate.changeset.rename_table(t, new_settings_name)

            print 'Not renaming settings:', e

    old_auth_name = 'internal' if old == 'kallithea' else old

    new_auth_name = 'internal' if new == 'kallithea' else new

    # using this API because ... dunno ... it is simple and works

    conn = metadata.bind.connect()

    trans = conn.begin()

    t = metadata.tables['users']

    print 'Bulk fixing of User extern_name'

    try:

        t.c.extern_name

    except AttributeError:

        print 'No extern_name to rename'

    else:

        t.update().where(t.c.extern_name == old_auth_name).values(extern_name=new_auth_name).execute()

    print 'Bulk fixing of User extern_type'

    try:

        t.c.extern_type

    except AttributeError:

        print 'No extern_type to rename'

    else:

        t.update().where(t.c.extern_type == old_auth_name).values(extern_type=new_auth_name).execute()

    trans.commit()

    # For the following conversions, use ORM ... and create stub models that works for that purpose

    Base = sqlalchemy.ext.declarative.declarative_base()

    class Ui(Base):

        __tablename__ = new_ui_name

        ui_id = Column("ui_id", Integer(), primary_key=True)

        ui_section = Column("ui_section", String())

        ui_key = Column("ui_key", String())

        ui_value = Column("ui_value", String())

        ui_active = Column("ui_active", Boolean())

    class Setting(Base):

        __tablename__ = new_settings_name

        app_settings_id = Column("app_settings_id", Integer(), primary_key=True)

        app_settings_name = Column("app_settings_name", String())

        app_settings_value = Column("app_settings_value", String())

        #app_settings_type = Column("app_settings_type", String()) # not present in v1.7.2

    class DbMigrateVersion(Base):

        __tablename__ = 'db_migrate_version'

        repository_id = Column('repository_id', String(), primary_key=True)

        repository_path = Column('repository_path', Text)

        version = Column('version', Integer)

    Session = sqlalchemy.orm.sessionmaker(bind=metadata.bind)

    session = Session()

    print 'Fixing hook names'

    oldhooks = u'python:%s.lib.hooks.' % old

    newhooks = u'python:%s.lib.hooks.' % new

    for u in session.query(Ui).filter(Ui.ui_section == 'hooks').all():

        if u.ui_value.startswith(oldhooks):

            print '- fixing %s' % u.ui_key

            u.ui_value = newhooks + u.ui_value[len(oldhooks):]

            session.add(u)

    session.commit()

    print 'Fixing auth module names'

    for s in session.query(Setting).filter(Setting.app_settings_name == 'auth_plugins').all():

        print '- fixing %s' % s.app_settings_name

        s.app_settings_value = (s.app_settings_value

                                .replace(old + '.lib.auth_modules.auth_', new + '.lib.auth_modules.auth_')

                                .replace('.auth_modules.auth_' + old_auth_name, '.auth_modules.auth_' + new_auth_name))

        session.add(s)

    for s in session.query(Setting).filter(Setting.app_settings_name == 'auth_' + old_auth_name + '_enabled').all():

        print '- fixing %s' % s.app_settings_name

        s.app_settings_name = 'auth_' + new_auth_name + '_enabled'

        session.add(s)

    session.commit()

    print 'Fixing db migration version number'

    for s in session.query(DbMigrateVersion).filter(DbMigrateVersion.repository_id == old + '_db_migrations', DbMigrateVersion.repository_path == 'versions').all():

        print '- fixing %s' % s.repository_id

        s.repository_id = new + '_db_migrations'

    session.commit()

    print 'Done'

def main(argv):

    if len(argv) < 2 or argv[1] in ['-h', '--help']:

        print 'usage: kallithea/bin/rebranddb.py DBSTRING [NEW] [OLD]'

        print '  where DBSTRING is the value of sqlalchemy.db1.url from the .ini,'

        print '  NEW defaults to "kallithea", OLD is by default detected from the db"'

        raise SystemExit(0)

    new = 'kallithea'

    if len(argv) > 2:

        new = argv[2]

    old = None

    if len(argv) > 3:

        old = argv[3]

    do_migrate(argv[1], old, new)

if __name__ == '__main__':

    main(sys.argv)

# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.controllers.admin.auth_settings

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

pluggable authentication controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 26, 2010

:author: akesterson

"""

import logging

import formencode.htmlfill

import traceback

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from kallithea.lib import helpers as h

from kallithea.lib.compat import formatted_json

from kallithea.lib.base import BaseController, render

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib import auth_modules

from kallithea.model.forms import AuthSettingsForm

from kallithea.model.db import Setting

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class AuthSettingsController(BaseController):

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        super(AuthSettingsController, self).__before__()

    def __load_defaults(self):

        c.available_plugins = [

            'kallithea.lib.auth_modules.auth_internal',

            'kallithea.lib.auth_modules.auth_container',

            'kallithea.lib.auth_modules.auth_ldap',

            'kallithea.lib.auth_modules.auth_crowd',

            'kallithea.lib.auth_modules.auth_pam'

        ]

        c.enabled_plugins = Setting.get_auth_plugins()

    def __render(self, defaults, errors):

        c.defaults = {}

        c.plugin_settings = {}

        c.plugin_shortnames = {}

        for module in c.enabled_plugins:

            plugin = auth_modules.loadplugin(module)

            plugin_name = plugin.name

            c.plugin_shortnames[module] = plugin_name

            c.plugin_settings[module] = plugin.plugin_settings()

            for v in c.plugin_settings[module]:

                fullname = ("auth_" + plugin_name + "_" + v["name"])

                if "default" in v:

                    c.defaults[fullname] = v["default"]

                # Current values will be the default on the form, if there are any

                setting = Setting.get_by_name(fullname)

                if setting is not None:

                    c.defaults[fullname] = setting.app_settings_value

        # we want to show , separated list of enabled plugins

        c.defaults['auth_plugins'] = ','.join(c.enabled_plugins)

        if defaults:

            c.defaults.update(defaults)

        log.debug(formatted_json(defaults))

        return formencode.htmlfill.render(

            render('admin/auth/auth_settings.html'),

            defaults=c.defaults,

            errors=errors,

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    def index(self):

        self.__load_defaults()

        return self.__render(defaults=None, errors=None)

    def auth_settings(self):

        """POST create and store auth settings"""

        self.__load_defaults()

        log.debug("POST Result: %s", formatted_json(dict(request.POST)))

        # First, parse only the plugin list (not the plugin settings).

        _auth_plugins_validator = AuthSettingsForm([]).fields['auth_plugins']

        try:

            new_enabled_plugins = _auth_plugins_validator.to_python(request.POST.get('auth_plugins'))

        except formencode.Invalid:

            # User provided an invalid plugin list. Just fall back to

            # the list of currently enabled plugins. (We'll re-validate

            # and show an error message to the user, below.)

            pass

        else:

            # Hide plugins that the user has asked to be disabled, but

            # do not show plugins that the user has asked to be enabled

            # (yet), since that'll cause validation errors and/or wrong

            # settings being applied (e.g. checkboxes being cleared),

            # since the plugin settings will not be in the POST data.

            c.enabled_plugins = [ p for p in c.enabled_plugins if p in new_enabled_plugins ]

        # Next, parse everything including plugin settings.

        _form = AuthSettingsForm(c.enabled_plugins)()

        try:

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

            for k, v in form_result.items():

                if k == 'auth_plugins':

                    # we want to store it comma separated inside our settings

                    v = ','.join(v)

                log.debug("%s = %s" % (k, str(v)))

                setting = Setting.create_or_update(k, v)

                Session().add(setting)

            Session().commit()

            h.flash(_('Auth settings updated successfully'),

                       category='success')

            log.error(traceback.format_exc())

            e = errors.error_dict or {}

            return self.__render(

                defaults=errors.value,

                errors=e,

            )

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of auth settings'),

                    category='error')

        return redirect(url('auth_home'))

# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.controllers.admin.defaults

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

default settings controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 27, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultsForm

from kallithea.model.meta import Session

from kallithea import BACKENDS

from kallithea.model.db import Setting

log = logging.getLogger(__name__)

class DefaultsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('default', 'defaults')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        super(DefaultsController, self).__before__()

    def index(self, format='html'):

        """GET /defaults: All items in the collection"""

        # url('defaults')

        c.backends = BACKENDS.keys()

        defaults = Setting.get_default_repo_settings()

        return htmlfill.render(

            render('admin/defaults/defaults.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def create(self):

        """POST /defaults: Create a new item"""

        # url('defaults')

    def new(self, format='html'):

        """GET /defaults/new: Form to create a new item"""

        # url('new_default')

    def update(self, id):

        """PUT /defaults/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('default', id=ID),

        #           method='put')

        # url('default', id=ID)

        _form = DefaultsForm()()

        try:

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

            for k, v in form_result.iteritems():

                setting = Setting.create_or_update(k, v)

                Session().add(setting)

            Session().commit()

            h.flash(_('Default settings updated successfully'),

                    category='success')

            defaults = errors.value

            return htmlfill.render(

                render('admin/defaults/defaults.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of defaults'),

                    category='error')

        return redirect(url('defaults'))

    def delete(self, id):

        """DELETE /defaults/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('default', id=ID),

        #           method='delete')

        # url('default', id=ID)

    def show(self, id, format='html'):

        """GET /defaults/id: Show a specific item"""

        # url('default', id=ID)

    def edit(self, id, format='html'):

        """GET /defaults/id/edit: Form to edit an existing item"""

        # url('edit_default', id=ID)

# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.controllers.admin.gist

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

gist controller for Kallithea