upstream/kallithea Commit - r43:2e1247e6

changed for pylons 0.1 / 1.0...

marcink -

r43:2e1247e6 default

parent child

pylons_app/controllers/admin.py

0 created 644 +87 0

@@ -0,0 +1,87 b''
	1	import logging
	2
	3	from pylons import request, response, session, tmpl_context as c, url, app_globals as g
	4	from pylons.controllers.util import abort, redirect
	5
	6	from pylons_app.lib.base import BaseController, render
	7	import os
	8	from mercurial import ui, hg
	9	from mercurial.error import RepoError
	10	from ConfigParser import ConfigParser
	11	log = logging.getLogger(__name__)
	12
	13	class AdminController(BaseController):
	14
	15
	16	def __before__(self):
	17	c.staticurl = g.statics
	18
	19	def index(self):
	20	# Return a rendered template
	21	return render('/admin.html')
	22
	23
	24	def manage_hgrc(self):
	25	pass
	26
	27	def hgrc(self, dirname):
	28	filename = os.path.join(dirname, '.hg', 'hgrc')
	29	return filename
	30
	31	def add_repo(self, new_repo):
	32
	33
	34	#extra check it can be add since it's the command
	35	if new_repo == 'add':
	36	c.msg = 'you basstard ! this repo is a command'
	37	c.new_repo = ''
	38	return render('add.html')
	39
	40	new_repo = new_repo.replace(" ", "_")
	41	new_repo = new_repo.replace("-", "_")
	42
	43	try:
	44	self._create_repo(new_repo)
	45	c.new_repo = new_repo
	46	c.msg = 'added repo'
	47	except Exception as e:
	48	c.new_repo = 'Exception when adding: %s' % new_repo
	49	c.msg = str(e)
	50
	51	return render('add.html')
	52
	53	def _check_repo(self, repo_name):
	54	p = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
	55	config_path = os.path.join(p, 'hgwebdir.config')
	56
	57	cp = ConfigParser()
	58
	59	cp.read(config_path)
	60	repos_path = cp.get('paths', '/').replace("**", '')
	61
	62	if not repos_path:
	63	raise Exception('Could not read config !')
	64
	65	self.repo_path = os.path.join(repos_path, repo_name)
	66
	67	try:
	68	r = hg.repository(ui.ui(), self.repo_path)
	69	hg.verify(r)
	70	#here we hnow that repo exists it was verified
	71	log.info('%s repo is already created', repo_name)
	72	raise Exception('Repo exists')
	73	except RepoError:
	74	log.info('%s repo is free for creation', repo_name)
	75	#it means that there is no valid repo there...
	76	return True
	77
	78
	79	def _create_repo(self, repo_name):
	80	if repo_name in [None, '', 'add']:
	81	raise Exception('undefined repo_name of repo')
	82
	83	if self._check_repo(repo_name):
	84	log.info('creating repo %s in %s', repo_name, self.repo_path)
	85	cmd = """mkdir %s && hg init %s""" \
	86	% (self.repo_path, self.repo_path)
	87	os.popen(cmd)

pylons_app/templates/admin.html

0 created 644 +51 0

@@ -0,0 +1,51 b''
	1	## -- coding: utf-8 --
	2	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
	3	<html xmlns="http://www.w3.org/1999/xhtml">
	4	<head>
	5	<link rel="icon" href="${c.staticurl}hgicon.png" type="image/png" />
	6	<meta name="robots" content="index, nofollow"/>
	7	<link rel="stylesheet" href="${c.staticurl}style-monoblue.css" type="text/css" />
	8	<title>Mercurial repositories Admin</title>
	9	</head>
	10
	11	<body>
	12	<div id="container">
	13	<div class="page-header">
	14	<h1><a href="/">Home</a> / Admin</h1>
	15	<ul class="page-nav">
	16	</ul>
	17	</div>
	18	<table cellspacing="0">
	19	<tr>
	20	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	21	</tr>
	22	<tr>
	23	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	24	</tr>
	25	<tr>
	26	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	27	</tr>
	28	<tr>
	29	<td><h2>${c.new_repo}</h2></td>
	30	</tr>
	31	</table>
	32	<div class="page-footer">
	33	Mercurial Repository: admin
	34	</div>
	35
	36	<div id="powered-by">
	37	<p>
	38	<a href="http://mercurial.selenic.com/" title="Mercurial">
	39	<img src="${c.staticurl}hglogo.png" width="75" height="90" alt="mercurial"></a>
	40	</p>
	41	</div>
	42
	43	<div id="corner-top-left"></div>
	44	<div id="corner-top-right"></div>
	45	<div id="corner-bottom-left"></div>
	46	<div id="corner-bottom-right"></div>
	47
	48	</div>
	49	</body>
	50	</html>
	51	No newline at end of file

pylons_app/tests/functional/test_admin.py

0 created 644 +7 0

@@ -0,0 +1,7 b''
	1	from pylons_app.tests import *
	2
	3	class TestAdminController(TestController):
	4
	5	def test_index(self):
	6	response = self.app.get(url(controller='admin', action='index'))
	7	# Test response...

pylons_app/config/environment.py

0 +30 -5

             """Pylons environment configuration"""
             import logging
             import os
             from mako.lookup import TemplateLookup
+            from pylons.configuration import PylonsConfig
             from pylons.error import handle_mako_error
-            from pylons import config
+            from sqlalchemy import engine_from_config
             import pylons_app.lib.app_globals as app_globals
             import pylons_app.lib.helpers
             from pylons_app.config.routing import make_map
+            from pylons_app.model import init_model
             log = logging.getLogger(__name__)
             def load_environment(global_conf, app_conf):
                 """Configure the Pylons environment via the ``pylons.config``
                 object
                 """
+                config = PylonsConfig()
                 # Pylons paths
                 root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
                 paths = dict(root=root,
                              controllers=os.path.join(root, 'controllers'),
                              static_files=os.path.join(root, 'public'),
                              templates=[os.path.join(root, 'templates')])
                 # Initialize config with the basic options
-                config.init_app(global_conf, app_conf, package='pylons_app',
+                config.init_app(global_conf, app_conf, package='pylons_app', paths=paths)
-                                template_engine='mako', paths=paths)
-                config['routes.map'] = make_map()
+                config['routes.map'] = make_map(config)
-                config['pylons.app_globals'] = app_globals.Globals()
+                config['pylons.app_globals'] = app_globals.Globals(config)
                 config['pylons.h'] = pylons_app.lib.helpers
+                # Setup cache object as early as possible
+                import pylons
+                pylons.cache._push_object(config['pylons.app_globals'].cache)
                 # Create the Mako TemplateLookup, with the default auto-escaping
                 config['pylons.app_globals'].mako_lookup = TemplateLookup(
                     directories=paths['templates'],
                     error_handler=handle_mako_error,
                     module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
                     input_encoding='utf-8', default_filters=['escape'],
                     imports=['from webhelpers.html import escape'])
+                #sets the c attribute access when don't existing attribute ar accessed
+                config['pylons.strict_tmpl_context'] = False
+                #MULTIPLE DB configs
+                # Setup the SQLAlchemy database engine
+            #    if config['debug']:
+            #        #use query time debugging.
+            #        from pylons_app.lib.timer_proxy import TimerProxy
+            #        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.',
+            #                                                            proxy=TimerProxy())
+            #    else:
+            #        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')
+                #init_model(sa_engine_db1)
                 # CONFIGURATION OPTIONS HERE (note: all config options will override
                 # any Pylons config options)
+                return config

pylons_app/config/middleware.py

0 +11 -9

             """Pylons middleware initialization"""
-            from beaker.middleware import CacheMiddleware, SessionMiddleware
+            from beaker.middleware import SessionMiddleware
             from paste.cascade import Cascade
             from paste.registry import RegistryManager
             from paste.urlparser import StaticURLParser
             from paste.deploy.converters import asbool
-            from pylons import config
             from pylons.middleware import ErrorHandler, StatusCodeRedirect
             from pylons.wsgiapp import PylonsApp
             from routes.middleware import RoutesMiddleware
             from paste.auth.basic import AuthBasicHandler
             from pylons_app.config.environment import load_environment
             from pylons_app.lib.auth import authfunc
-            def make_app(global_conf, full_stack=True, **app_conf):
+            def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
                 """Create a Pylons WSGI application and return it
                 ``global_conf``
                     The inherited configuration for this application. Normally from
                     the [DEFAULT] section of the Paste ini file.
                 ``full_stack``
                     Whether or not this application provides a full WSGI stack (by
                     default, meaning it handles its own exceptions and errors).
                     Disable full_stack when this application is "managed" by
                     another WSGI middleware.
                 ``app_conf``
                     The application's local configuration. Normally specified in
                     the [app:<name>] section of the Paste ini file (where <name>
                     defaults to main).
                 """
                 # Configure the Pylons environment
-                load_environment(global_conf, app_conf)
+                config = load_environment(global_conf, app_conf)
                 # The Pylons WSGI app
-                app = PylonsApp()
+                app = PylonsApp(config=config)
                 # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
                 # Routing/Session/Cache Middleware
                 app = RoutesMiddleware(app, config['routes.map'])
                 app = SessionMiddleware(app, config)
-                app = CacheMiddleware(app, config)
                 app = AuthBasicHandler(app, config['repos_name'] + ' mercurial repository', authfunc)
                 if asbool(full_stack):
                     # Handle Python exceptions
                     app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
                     # Display error documents for 401, 403, 404 status codes (and
                     # 500 when debug is disabled)
                     if asbool(config['debug']):
                         #don't handle 404, since mercurial does it for us.
-                        app = StatusCodeRedirect(app, [400, 401, 403, 500])
+                        app = StatusCodeRedirect(app, [400, 401, 403])
                     else:
                         app = StatusCodeRedirect(app, [400, 401, 403, 500])
                 # Establish the Registry for this application
                 app = RegistryManager(app)
-                # Static files (If running in production, and Apache or another web
+                if asbool(static_files):
-                # server is handling this static content, remove the following 3 lines)
+                    # Serve static files
                     static_app = StaticURLParser(config['pylons.paths']['static_files'])
                     app = Cascade([static_app, app])
+                    app.config = config
                 return app

pylons_app/config/routing.py

0 +9 -7

             """Routes configuration
             The more specific and detailed routes should be defined first so they
             may take precedent over the more generic routes. For more information
             refer to the routes manual at http://routes.groovie.org/docs/
             """
-            from pylons import config
             from routes import Mapper
-            def make_map():
+            def make_map(config):
                 """Create, configure and return the routes Mapper"""
                 map = Mapper(directory=config['pylons.paths']['controllers'],
                              always_scan=config['debug'])
                 map.minimization = False
+                map.explicit = False
                 # The ErrorController route (handles 404/500 error pages); it should
                 # likely stay at the top, ensuring it can always be resolved
                 map.connect('/error/{action}', controller='error')
                 map.connect('/error/{action}/{id}', controller='error')
                 # CUSTOM ROUTES HERE
-                map.connect('hg_add', '/add/{new_repo:[a-z0-9\. _-]*}',
+                with map.submapper(path_prefix='/_admin', controller='admin') as m:
-                            controller = 'hg', action = 'add_repo')
+                    m.connect('admin_home', '/', action='index')#main page
-                map.connect('hg', '/{path_info:.*}',
+                    m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}', action='add_repo')
-                            controller = 'hg', action = "view",
+                    m.connect('admin_manage_users', '/manage_users', action='index')
-                            path_info = '/')
+                map.connect('hg', '/{path_info:.*}', controller='hg',
+                            action="view", path_info='/')
                 return map

pylons_app/controllers/hg.py

0 +1 -94

@@ -1,134 +1,41 b''
1	#!/usr/bin/python	1	#!/usr/bin/python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	import logging	3	import logging
4	import os	4	from pylons_app.lib.base import BaseController
5	from pylons_app.lib.base import BaseController, render
6	from pylons import tmpl_context as c, app_globals as g, session, request, config	5	from pylons import tmpl_context as c, app_globals as g, session, request, config
7	from pylons_app.lib import helpers as h	6	from pylons_app.lib import helpers as h
8	from mako.template import Template	7	from mako.template import Template
9	from mercurial import ui, hg
10	from mercurial.error import RepoError
11	from ConfigParser import ConfigParser
12	from pylons.controllers.util import abort	8	from pylons.controllers.util import abort
13		9
14	log = logging.getLogger(__name__)	10	log = logging.getLogger(__name__)
15		11
16	class HgController(BaseController):	12	class HgController(BaseController):
17		13
18	def __before__(self):	14	def __before__(self):
19	c.repos_prefix = config['repos_name']	15	c.repos_prefix = config['repos_name']
20		16
21	def view(self, args, *kwargs):	17	def view(self, args, *kwargs):
22	response = g.hgapp(request.environ, self.start_response)	18	response = g.hgapp(request.environ, self.start_response)
23		19
24	http_accept = request.environ.get('HTTP_ACCEPT', False)	20	http_accept = request.environ.get('HTTP_ACCEPT', False)
25	if not http_accept:	21	if not http_accept:
26	return abort(status_code=400, detail='no http accept in header')	22	return abort(status_code=400, detail='no http accept in header')
27		23
28	#for mercurial protocols and raw files we can't wrap into mako	24	#for mercurial protocols and raw files we can't wrap into mako
29	if http_accept.find("mercurial") != -1 or \	25	if http_accept.find("mercurial") != -1 or \
30	request.environ['PATH_INFO'].find('raw-file') != -1:	26	request.environ['PATH_INFO'].find('raw-file') != -1:
31	return response	27	return response
32	try:	28	try:
33	tmpl = u''.join(response)	29	tmpl = u''.join(response)
34	template = Template(tmpl, lookup=request.environ['pylons.pylons']\	30	template = Template(tmpl, lookup=request.environ['pylons.pylons']\
35	.config['pylons.app_globals'].mako_lookup)	31	.config['pylons.app_globals'].mako_lookup)
36		32
37	except (RuntimeError, UnicodeDecodeError):	33	except (RuntimeError, UnicodeDecodeError):
38	log.info('disabling unicode due to encoding error')	34	log.info('disabling unicode due to encoding error')
39	response = g.hgapp(request.environ, self.start_response)	35	response = g.hgapp(request.environ, self.start_response)
40	tmpl = ''.join(response)	36	tmpl = ''.join(response)
41	template = Template(tmpl, lookup=request.environ['pylons.pylons']\	37	template = Template(tmpl, lookup=request.environ['pylons.pylons']\
42	.config['pylons.app_globals'].mako_lookup, disable_unicode=True)	38	.config['pylons.app_globals'].mako_lookup, disable_unicode=True)
43		39
44		40
45	return template.render(g=g, c=c, session=session, h=h)	41	return template.render(g=g, c=c, session=session, h=h)
46
47
48	def manage_hgrc(self):
49	pass
50
51	def hgrc(self, dirname):
52	filename = os.path.join(dirname, '.hg', 'hgrc')
53	return filename
54
55	def add_repo(self, new_repo):
56	c.staticurl = g.statics
57
58	#extra check it can be add since it's the command
59	if new_repo == 'add':
60	c.msg = 'you basstard ! this repo is a command'
61	c.new_repo = ''
62	return render('add.html')
63
64	new_repo = new_repo.replace(" ", "_")
65	new_repo = new_repo.replace("-", "_")
66
67	try:
68	self._create_repo(new_repo)
69	c.new_repo = new_repo
70	c.msg = 'added repo'
71	except Exception as e:
72	c.new_repo = 'Exception when adding: %s' % new_repo
73	c.msg = str(e)
74
75	return render('add.html')
76
77	def _check_repo(self, repo_name):
78	p = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
79	config_path = os.path.join(p, 'hgwebdir.config')
80
81	cp = ConfigParser()
82
83	cp.read(config_path)
84	repos_path = cp.get('paths', '/').replace("**", '')
85
86	if not repos_path:
87	raise Exception('Could not read config !')
88
89	self.repo_path = os.path.join(repos_path, repo_name)
90
91	try:
92	r = hg.repository(ui.ui(), self.repo_path)
93	hg.verify(r)
94	#here we hnow that repo exists it was verified
95	log.info('%s repo is already created', repo_name)
96	raise Exception('Repo exists')
97	except RepoError:
98	log.info('%s repo is free for creation', repo_name)
99	#it means that there is no valid repo there...
100	return True
101
102
103	def _create_repo(self, repo_name):
104	if repo_name in [None, '', 'add']:
105	raise Exception('undefined repo_name of repo')
106
107	if self._check_repo(repo_name):
108	log.info('creating repo %s in %s', repo_name, self.repo_path)
109	cmd = """mkdir %s && hg init %s""" \
110	% (self.repo_path, self.repo_path)
111	os.popen(cmd)
112
113	#def _make_app():
114	# #for single a repo
115	# #return hgweb("/path/to/repo", "Name")
116	# repos = "hgwebdir.config"
117	# return hgwebdir(repos)
118	#
119
120	# def view(self, environ, start_response):
121	# #the following is only needed when using hgwebdir
122	# app = _make_app()
123	# #return wsgi_app(environ, start_response)
124	# response = app(request.environ, self.start_response)
125	#
126	# if environ['PATH_INFO'].find("static") != -1:
127	# return response
128	# else:
129	# #wrap the murcurial response in a mako template.
130	# template = Template("".join(response),
131	# lookup = environ['pylons.pylons']\
132	# .config['pylons.g'].mako_lookup)
133	#
134	# return template.render(g = g, c = c, session = session, h = h)

pylons_app/lib/app_globals.py

0 +5 -1

             """The application's Globals object"""
             #uncomment the following if you want to serve a single repo
             #from mercurial.hgweb.hgweb_mod import hgweb
             from mercurial.hgweb.hgwebdir_mod import hgwebdir
             from mercurial import templater
             from mercurial.hgweb.request import wsgiapplication
             from mercurial import ui, config
             import os
+            from beaker.cache import CacheManager
+            from beaker.util import parse_cache_config_options
             class Globals(object):
                 """Globals acts as a container for objects available throughout the
                 life of the application
                 """
-                def __init__(self):
+                def __init__(self, config):
                     """One instance of Globals is created during application
                     initialization and is available during requests via the
                     'app_globals' variable
                     """
                     #two ways of building the merc app i don't know
                     #the fastest one but belive the wsgiapp is better
                     #self.hgapp = self.make_web_app()
+                    self.cache = CacheManager(**parse_cache_config_options(config))
                     self.hgapp = wsgiapplication(self.make_web_app)
                 def make_web_app(self):
                     repos = "hgwebdir.config"
                     baseui = ui.ui()
                     cfg = config.config()
                     cfg.read(repos)
                     paths = cfg.items('paths')
                     self.check_repo_dir(paths)
                     self.set_statics(cfg)
                     for k, v in cfg.items('web'):
                         baseui.setconfig('web', k, v)
                     #magic trick to make our custom template dir working
                     templater.path.append(cfg.get('web', 'templates', None))
                     #baseui.setconfig('web', 'description', '')
                     #baseui.setconfig('web', 'name', '')
                     #baseui.setconfig('web', 'contact', '')
                     #baseui.setconfig('web', 'allow_archive', '')
                     #baseui.setconfig('web', 'style', 'monoblue_plain')
                     #baseui.setconfig('web', 'baseurl', '')
                     #baseui.setconfig('web', 'staticurl', '')
                     hgwebapp = hgwebdir(paths, baseui=baseui)
                     return hgwebapp
                 def set_statics(self, cfg):
                     '''
                     set's the statics for use in mako templates
                     @param cfg:
                     '''
                     self.statics = cfg.get('web', 'staticurl', '/static')
                     if not self.statics.endswith('/'):
                         self.statics += '/'
                 def check_repo_dir(self, paths):
                     repos_path = paths[0][1].split('/')
                     if repos_path[-1] in ['*', '**']:
                         repos_path = repos_path[:-1]
                     if repos_path[0] != '/':
                         repos_path[0] = '/'
                     if not os.path.isdir(os.path.join(*repos_path)):
                         raise Exception('Not a valid repository in %s' % paths[0][1])

pylons_app/lib/helpers.py

0 +3 -4

             """Helper functions
             Consists of functions to typically be used within templates, but also
             available to Controllers. This module is available to both as 'h'.
             """
-            from routes import redirect_to, url_for
+            from pylons import url
             from webhelpers.html import (literal, HTML, escape)
             from webhelpers.html.tools import (auto_link, button_to, highlight, js_obfuscate
                                                , mail_to, strip_links, strip_tags, tag_re)
             from webhelpers.html.tags import (auto_discovery_link, checkbox, css_classes,
                                               end_form, file, form, hidden, image,
                                               javascript_link, link_to, link_to_if,
                                               link_to_unless, ol, required_legend,
                                               select, stylesheet_link,
                                               submit, text, textarea, title, ul, xml_declaration)
             from webhelpers.text import (chop_at, collapse, convert_accented_entities,
                                          convert_misc_characters, convert_misc_entities,
                                          lchop, plural, rchop, remove_formatting, replace_whitespace,
                                          urlify)
             from webhelpers.pylonslib import Flash as _Flash
             from webhelpers.pylonslib.secure_form import secure_form
             #Custom helper here :)
             class _Link(object):
                 '''
                 Make a url based on label and url with help of url_for
                 @param label:name of link    if not defined url is used
                 @param url: the url for link
                 '''
-                def __call__(self, label = '', *url, **urlargs):
+                def __call__(self, label='', *url_, **urlargs):
                     if label is None or '':
                         label = url
-                    link_fn = link_to(label, url_for(*url, **urlargs))
+                    link_fn = link_to(label, url(*url_, **urlargs))
                     return link_fn
             class _GetError(object):
                 def __call__(self, field_name, form_errors):
                     tmpl = """<span class="error_msg">%s</span>"""
                     if form_errors and form_errors.has_key(field_name):
                         return literal(tmpl % form_errors.get(field_name))
             link = _Link()
             flash = _Flash()
             get_error = _GetError()

pylons_app/templates/monoblue_custom/notfound.tmpl

0 +4 -1

             ## -*- coding: utf-8 -*-
             {header}
                 <title>{repo|escape}: Mercurial repository not found</title>
             </head>
             <body>
             <div id="container">
                 <div class="page-header">
                     <h1>Not found: {repo|escape}</h1>
                     <div style="height: 50px">
                     </div>
                 </div>
                 <h2 class="no-link no-border">Not Found</h2>
                 <p class="normal">The specified repository "{repo|escape}" is unknown, sorry.</p>
-                <p class="normal"><a href="/add/{repo|escape}">Create "{repo|escape}" repository </a></p>
+                <p class="normal">
+                <a href="/_admin/add_repo/{repo|escape}">Create "{repo|escape}" repository</a>
+                </p>
                 <p class="normal">Go back to the <a href="{url}">main repository list page</a>.</p>
                 <div class="page-footer">
                     <p>Mercurial Repository: {repo|escape}</p>
                 </div>
                 <div id="powered-by">
                     <p><a href="http://mercurial.selenic.com/" title="Mercurial"><img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a></p>
                 </div>
                 <div id="corner-top-left"></div>
                 <div id="corner-top-right"></div>
                 <div id="corner-bottom-left"></div>
                 <div id="corner-bottom-right"></div>
             </div>
             </body>
             </html>

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages