implab/implabjs-core Commit - r41:eae7e609c38a

tests

cin -

r41:eae7e609c38a di-typescript

parent child

Context file:

r41:eae7e609c38a

Collapse all files

test/ts/mock/Bar.ts created 644 +3 0

@@ -0,0 +1,3
	1	export class Bar {
	2	name = "bar";
	3	}

test/ts/mock/Foo.ts created 644 +3 0

@@ -0,0 +1,3
	1	export class Foo {
	2	name = "foo";
	3	}

license +1 -1

-            Copyright 2017-2018 Implab team
+            Copyright 2017-2019 Implab team
             Redistribution and use in source and binary forms, with or without
             modification, are permitted provided that the following conditions are met:

package-lock.json +7 -7

                 },
                 "duplexer": {
                   "version": "0.1.1",
-                  "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
+                  "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
                   "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
                   "dev": true
                 },
                   "dependencies": {
                     "tape": {
                       "version": "2.3.3",
-                      "resolved": "http://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
+                      "resolved": "https://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
                       "integrity": "sha1-Lnzgox3wn41oUWZKcYQuDKUFevc=",
                       "dev": true,
                       "requires": {
                 },
                 "path-is-absolute": {
                   "version": "1.0.1",
-                  "resolved": "http://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+                  "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
                   "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
                   "dev": true
                 },
                 },
                 "readable-stream": {
                   "version": "1.1.14",
-                  "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+                  "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
                   "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
                   "dev": true,
                   "requires": {
                 },
                 "string_decoder": {
                   "version": "0.10.31",
-                  "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+                  "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
                   "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
                   "dev": true
                 },
                 },
                 "through": {
                   "version": "2.3.8",
-                  "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
+                  "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
                   "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
                   "dev": true
                 },
                 "through2": {
                   "version": "0.2.3",
-                  "resolved": "http://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
+                  "resolved": "https://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
                   "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=",
                   "dev": true,
                   "requires": {

src/ts/di/ActivationContext.ts +29 -31

             export interface ActivationContextInfo {
                 name: string;
-                service: Descriptor;
+                service: string;
                 scope: ServiceMap;
             }
                 _visited: object;
+                _name: string;
+                _localized: boolean;
                 container: Container;
-                constructor(container: Container, services: ServiceMap, cache?: object, visited?) {
+                constructor(container: Container, services: ServiceMap, name?: string, cache?: object, visited?) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
+                    this._name = name;
                     this._visited = visited || {};
                     this._stack = [];
                     this._cache = cache || {};
                     this.container = container;
                 }
-                getService(name, def?): any {
+                getName() {
+                    return this._name;
+                }
+                resolve(name, def?): any {
                     const d = this._services[name];
                     if (!d)
                         else
                             throw new Error(`Service ${name} not found`);
-                    return isDescriptor(d) ? d.activate(this, name) : d;
+                    return this.activate(d, name);
                 }
                 /**
                 clone() {
                     return new ActivationContext(
                         this.container,
-                        Object.create(this._services),
+                        this._services,
+                        this._name,
                         this._cache,
                         this._visited
                     );
                     return (this._cache[id] = value);
                 }
-                parse(data, name: string) {
+                activate(d: Descriptor, name: string) {
-                    if (isPrimitive(data))
+                    if (trace.isLogEnabled())
-                        return data;
+                        trace.log(`enter ${name} ${d}`);
-                    if (isDescriptor(data)) {
+                    this.enter(name, d.toString());
-                        return data.activate(this, name);
+                    const v = d.activate(this);
-                    } else if (data instanceof Array) {
-                        this.enter(name);
-                        const v = data.map( (x, i) => this.parse(x, `[${i}]`));
                     this.leave();
+                    if (trace.isLogEnabled())
+                        trace.log(`leave ${name}`);
                     return v;
-                    } else {
-                        this.enter(name);
-                        const result = {};
-                        for (const p in data)
-                            result[p] = this.parse(data[p], "." + p);
-                        this.leave();
-                        return result;
                 }
                 visit(id: string) {
                     return this._stack.slice().reverse();
                 }
-                enter(name: string, d?: Descriptor, localize?: boolean) {
+                private enter(name: string, service: string) {
-                    if (trace.isLogEnabled())
-                        trace.log("enter " + name + " " + (d || "") +
-                            (localize ? " localize" : ""));
                     this._stack.push({
                         name,
-                        service: d,
+                        service,
                         scope: this._services
                     });
-                    if (localize)
+                    this._name = name;
                     this._services = Object.create(this._services);
                 }
-                leave() {
+                private leave() {
                     const ctx = this._stack.pop();
                     this._services = ctx.scope;
+                    this._name = ctx.name;
-                    if (trace.isLogEnabled())
-                        trace.log("leave " + ctx.name + " " + (ctx.service || ""));
                 }
             }

src/ts/di/ActivationError.ts +1 -1

                     if (this.activationStack) {
                         parts.push("at");
                         this.activationStack
-                            .forEach(x => parts.push(`    ${x.name} ${x.service ? x.service.toString() : ""}`));
+                            .forEach(x => parts.push(`    ${x.name} ${x.service}`));
                     }

src/ts/di/AggregateDescriptor.ts +23 -10

@@ -1,5 +1,6
1	import { Descriptor } from "./interfaces";	1	import { Descriptor, isDescriptor } from "./interfaces";
2	import { ActivationContext } from "./ActivationContext";	2	import { ActivationContext } from "./ActivationContext";
		3	import { isPrimitive } from "util";
3		4
4	export class AggregateDescriptor implements Descriptor {	5	export class AggregateDescriptor implements Descriptor {
5	_value: object;	6	_value: object;
@@ -8,17 +9,29 export class AggregateDescriptor impleme
8	this._value = value;	9	this._value = value;
9	}	10	}
10		11
11	activate(context: ActivationContext, ~~name~~: ~~string~~) {	12	activate(context: ActivationContext) {
12	context.enter(name);	13	return this._parse(this._value, context, "$value");
13	const v = context.parse(this._value, ".params");
14	context.leave();
15	return v;
16	}	14	}
17		15
18	isInstanceCreated(): boolean {	16	// TODO: make async
19	return false;	17	_parse(value, context: ActivationContext, path: string) {
		18	if (isPrimitive(value))
		19	return value;
		20
		21	if (isDescriptor(value))
		22	return context.activate(value, path);
		23
		24	if (value instanceof Array)
		25	return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
		26
		27	const t = {};
		28	for (const p of Object.keys(value))
		29	t[p] = this._parse(value[p], context, `${path}.${p}`);
		30	return t;
		31
20	}	32	}
21	getInstance(): any {	33
22	throw new Error("Not supported");	34	toString() {
		35	return "@walk";
23	}	36	}
24	}	37	}

src/ts/di/Container.ts +59 -40

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration } from "./interfaces";
+            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration, DependencyRegistration } from "./interfaces";
             import { AggregateDescriptor } from "./AggregateDescriptor";
-            import { isPrimitive } from "../safe";
+            import { isPrimitive, pmap } from "../safe";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { ModuleResolverBase } from "./ModuleResolverBase";
             import format = require("../text/format");
+            import { throws } from "assert";
             export class Container {
                 _services: ServiceMap;
                     return this._parent;
                 }
-                getService(name: string, def?) {
+                resolve(name: string, def?) {
                     const d = this._services[name];
-                    if (!d)
+                    if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
+                    }
-                    if (!isDescriptor(d))
-                        return d;
-                    if (d.isInstanceCreated())
-                        return d.getInstance();
                     const context = new ActivationContext(this, this._services);
                     try {
-                        return d.activate(context, name);
+                        return context.activate(d, name);
                     } catch (error) {
                         throw new ActivationError(name, context.getStack(), error);
                     }
                 }
+                getService(name: string, def?) {
+                    return this.resolve.apply(this, arguments);
+                }
                 register(nameOrCollection, service?) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection;
                         for (const name in data)
                             this.register(name, data[name]);
                     } else {
+                        if (!isDescriptor(service))
+                            throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection] = service;
                     }
                     return this;
                 async _configure(data: object, opts?: { resolver: ModuleResolverBase }) {
                     const resolver = (opts && opts.resolver) || this._resolver;
-                    const services: ServiceMap = {};
+                    const services = await this._parseRegistrations(data, resolver);
-                    resolver.beginBatch();
-                    async function parse(k) {
-                        services[k] = await this._parse(data[k], resolver);
-                    const batch = Object.keys(data).map(parse);
-                    resolver.completeBatch();
-                    await Promise.all(batch);
                     this.register(services);
                 }
                         return registration;
                     if (isDependencyRegistration(registration)) {
+                        return this._paseReference(registration, resolver);
-                        return new ReferenceDescriptor({
-                            name: registration.$dependency,
-                            lazy: registration.lazy,
-                            optional: registration.optional,
-                            default: registration.default,
-                            services: registration.services && this._parseObject(registration.services, resolver)
-                        });
                     } else if (isValueRegistration(registration)) {
                         return !registration.parse ?
                             new ValueDescriptor(registration.$value) :
                             new AggregateDescriptor(this._parse(registration.$value, resolver));
                     return this._parseObject(registration, resolver);
                 }
+                async _paseReference(registration: DependencyRegistration, resolver: ModuleResolverBase) {
+                    return new ReferenceDescriptor({
+                        name: registration.$dependency,
+                        lazy: registration.lazy,
+                        optional: registration.optional,
+                        default: registration.default,
+                        services: registration.services && await this._parseRegistrations(registration.services, resolver)
+                    });
+                }
                 async _parseService(data: ServiceRegistration, resolver: ModuleResolverBase) {
                     const opts: ServiceDescriptorParams = {
                         owner: this
                     }
                     if (data.services)
-                        opts.services = await this._parseObject(data.services, resolver);
+                        opts.services = await this._parseRegistrations(data.services, resolver);
+                    if (data.inject) {
                         if (data.inject instanceof Array)
                             opts.inject = await Promise.all(data.inject.map(x => this._parseObject(x, resolver)));
                         else
                             opts.inject = [await this._parseObject(data.inject, resolver)];
+                    }
                     if (data.params)
                         opts.params = this._parse(data.params, resolver);
                     return new ServiceDescriptor(opts);
                 }
-                _parseObject(data: object, resolver: ModuleResolverBase) {
+                async _parseObject(data: object, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     const o = {};
                     for (const p in data)
-                        o[p] = this._parse(data[p], resolver);
+                        o[p] = await this._parse(data[p], resolver);
+                    // TODO: handle inline descriptors properly
+                    // const ex = {
+                    //     activate(ctx) {
+                    //         const value = ctx.activate(this.prop, "prop");
+                    //         // some code
+                    //     },
+                    //     // will be turned to ReferenceDescriptor
+                    //     prop: { $dependency: "depName" }
+                    // };
                     return o;
                 }
-                _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
+                async _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
-                    return data.map(x => this._parse(x, resolver));
+                    return pmap(data, x => this._parse(x, resolver));
+                }
+                async _parseRegistrations(data: object, resolver: ModuleResolverBase) {
+                    if (data.constructor &&
+                        data.constructor.prototype !== Object.prototype)
+                        throw new Error("Registrations must be a simple object");
+                    const o: ServiceMap = {};
+                    for (const p of Object.keys(data)) {
+                        const v = await this._parse(data[p], resolver);
+                        o[p] = isDescriptor(v) ? v : new AggregateDescriptor(v);
+                    }
+                    return o;
                 }
             }

src/ts/di/ReferenceDescriptor.ts +9 -23

                     this._name = opts.name;
                     this._lazy = !!opts.lazy;
                     this._optional = !!opts.optional;
-                    this._default = !!opts.default;
+                    this._default = opts.default;
                     this._services = opts.services;
                 }
                 activate(context: ActivationContext, name: string) {
-                    if (this._lazy) {
-                        // сохраняем контекст активации
-                        context = context.clone();
                     // добавляем сервисы
                     if (this._services) {
                         for (const p of Object.keys(this._services))
                             context.register(p, this._services[p]);
                     }
+                    if (this._lazy) {
+                        const saved = context.clone();
                         return (cfg: ServiceMap) => {
                             // защищаем контекст на случай исключения в процессе
                             // активации
-                            const ct = context.clone();
+                            const ct = saved.clone();
                             try {
                                 if (cfg) {
                                     for (const k in cfg)
                                         ct.register(k, cfg[k]);
                                 }
-                                return this._optional ? ct.getService(this._name, this._default) : ct
+                                return this._optional ? ct.resolve(this._name, this._default) : ct
-                                    .getService(this._name);
+                                    .resolve(this._name);
                             } catch (error) {
                                 throw new ActivationError(this._name, ct.getStack(), error);
                             }
                         };
                     } else {
-                        context.enter(name, this, !!this._services);
                         // добавляем сервисы
                         if (this._services) {
                             for (const p of Object.keys(this._services))
                         }
                         const v = this._optional ?
-                        context.getService(this._name, this._default) :
+                            context.resolve(this._name, this._default) :
-                        context.getService(this._name);
+                            context.resolve(this._name);
-                        context.leave();
                         return v;
                     }
                 }
-                isInstanceCreated() {
-                    return false;
-                getInstance() {
-                    throw new Error("The reference descriptor doesn't allowed to hold an instance");
                 toString() {
                     const opts = [];
                     if (this._optional)

src/ts/di/ServiceDescriptor.ts +32 -19

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ActivationType, ServiceMap } from "./interfaces";
+            import { Descriptor, ActivationType, ServiceMap, isDescriptor } from "./interfaces";
             import { Container } from "./Container";
             import { argumentNotNull, isPrimitive, oid, isPromise } from "../safe";
             import { Constructor, Factory } from "../interfaces";
+            import { TraceSource } from "../log/TraceSource";
             let cacheId = 0;
+            const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod(target, method, context, args) {
                 const m = target[method];
                 if (!m)
                 }
             }
+            // TODO: make async
+            function _parse(value, context: ActivationContext, path: string) {
+                if (isPrimitive(value))
+                    return value;
+                if (isDescriptor(value))
+                    return context.activate(value, path);
+                if (value instanceof Array)
+                    return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
+                const t = {};
+                for (const p of Object.keys(value))
+                    t[p] = this._parse(value[p], context, `${path}.${p}`);
+                return t;
+            }
             export interface ServiceDescriptorParams {
                 activation?: ActivationType;
                     }
                 }
-                activate(context: ActivationContext, name: string) {
+                activate(context: ActivationContext) {
                     // if we have a local service records, register them first
                     let instance;
                             if (container.has(this._cacheId)) {
                                 instance = container.get(this._cacheId);
                             } else {
-                                instance = this._create(context, name);
+                                instance = this._create(context);
                                 container.store(this._cacheId, instance);
                                 if (this._cleanup)
                                     container.onDispose(
                                 return this._instance;
                             // create an instance
-                            instance = this._create(context, name);
+                            instance = this._create(context);
                             // the instance is bound to the container
                             if (this._cleanup)
                             if (context.has(this._cacheId))
                                 return context.get(this._cacheId);
                             // context context activated instances are controlled by callers
-                            return context.store(this._cacheId, this._create(
+                            return context.store(this._cacheId, this._create(context));
-                                context,
-                                name));
                         case ActivationType.Call: // CALL
                             // per-call created instances are controlled by callers
-                            return this._create(context, name);
+                            return this._create(context);
                         case ActivationType.Hierarchy: // HIERARCHY
                             // hierarchy activated instances are behave much like container activated
                             // except they are created and bound to the child container
                             if (context.container.has(this._cacheId))
                                 return context.container.get(this._cacheId);
-                            instance = this._create(context, name);
+                            instance = this._create(context);
                             if (this._cleanup)
                                 context.container.onDispose(makeClenupCallback(
                     return this._instance;
                 }
-                _create(context, name) {
+                _create(context: ActivationContext) {
-                    context.enter(name, this, Boolean(this._services));
+                    trace.debug(`constructing ${context._name}`);
                     if (this._activationType !== ActivationType.Call &&
                         context.visit(this._cacheId) > 0)
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
-                        instance = this._factory.apply(this, context.parse(
+                        instance = this._factory.apply(this, _parse(this._params, context, "args"));
-                            this._params,
-                            ".params"));
                     } else {
-                        instance = this._factory(context.parse(
+                        instance = this._factory(_parse(this._params, context, "args"));
-                            this._params,
-                            ".params"));
                     }
                     if (this._inject) {
                         });
                     }
-                    context.leave();
                     return instance;
                 }

src/ts/di/ValueDescriptor.ts +5 -11

@@ -1,5 +1,4
1	import { Descriptor } from "./interfaces";	1	import { Descriptor } from "./interfaces";
2	import { ActivationContext } from "./ActivationContext";
3		2
4	export class ValueDescriptor implements Descriptor {	3	export class ValueDescriptor implements Descriptor {
5	_value;	4	_value;
@@ -8,16 +7,11 export class ValueDescriptor implements
8	this._value = value;	7	this._value = value;
9	}	8	}
10		9
11	activate(context: ActivationContext, name: string) {	10	activate() {
12	context.enter(name);
13	const v = this._value;
14	context.leave();
15	return v;
16	}
17	isInstanceCreated(): boolean {
18	return true;
19	}
20	getInstance() {
21	return this._value;	11	return this._value;
22	}	12	}
		13
		14	toString() {
		15	return `@type=${typeof this._value}`;
23	}	16	}
		17	}

src/ts/di/interfaces.ts +1 -3

             export interface Descriptor {
                 activate(context: ActivationContext, name?: string);
-                isInstanceCreated(): boolean;
-                getInstance();
             }
             export function isDescriptor(x): x is Descriptor {
             }
             export interface ServiceMap {
-                [s: string]: any;
+                [s: string]: Descriptor;
             }
             export enum ActivationType {

src/ts/safe.ts +2 -2

             let _nextOid = 0;
-            const _oid = Symbol("__oid");
+            const _oid = typeof Symbol === "function" ? Symbol("__oid") : "__oid";
             export function oid(instance: object): string {
                 if (isNull(instance))
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
-                if (items && items.then instanceof Function)
+                if (isPromise(items))
                     return items.then(data => pmap(data, cb));
                 if (isNull(items) || !items.length)

test/ts/ContainerTests.ts +52 -4

@@ -1,14 +1,26
1	import { test } from "./TestTraits";	1	import { test, TapeWriter } from "./TestTraits";
2	import { Container } from "@implab/core/di/Container";	2	import { Container } from "@implab/core/di/Container";
3	import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";	3	import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";
4	import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";	4	import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";
		5	import { ValueDescriptor } from "@implab/core/di/ValueDescriptor";
		6	import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
		7	import { Foo } from "./mock/Foo";
		8	import { Bar } from "./mock/Bar";
		9	import { isNull } from "@implab/core/safe";
5		10
6	test("Container register/~~getServic~~e tests", async t => {	11	test("Container register/resolve tests", async t => {
		12	const writer = new TapeWriter(t);
		13
		14	TraceSource.on(ts => {
		15	ts.level = DebugLevel;
		16	writer.writeEvents(ts.events);
		17	});
		18
7	const container = new Container();	19	const container = new Container();
8		20
9	const connection1 = "db://localhost";	21	const connection1 = "db://localhost";
10		22
11	container.register("connection", connection1);	23	container.register("connection", new ValueDescriptor(connection1));
12		24
13	t.equals(container.getService("connection"), connection1);	25	t.equals(container.getService("connection"), connection1);
14		26
@@ -21,6 +33,42 test("Container register/getService test
21	);	33	);
22		34
23	const dbParams = container.getService("dbParams");	35	const dbParams = container.getService("dbParams");
24	t.equals(dbParams.connection, connection1);	36	t.equals(dbParams.connection, connection1, "should get connection");
		37
		38	writer.destroy();
		39	});
		40
		41	test("Container configure/resolve tests", async t => {
		42	const writer = new TapeWriter(t);
		43
		44	TraceSource.on(ts => {
		45	ts.level = DebugLevel;
		46	writer.writeEvents(ts.events);
		47	});
		48
		49	const container = new Container();
		50
		51	await container.configure({
		52	foo: {
		53	$type: Foo
		54	},
25		55
		56	bar: {
		57	$type: Bar,
		58	params: {
		59	db: {
		60	provider: {
		61	$dependency: "db"
		62	}
		63	}
		64	}
		65	}
26	});	66	});
		67
		68	const f1 = container.resolve("foo");
		69	t.assert(!isNull(f1), "foo should be not null");
		70
		71	const b1 = container.resolve("bar");
		72
		73	writer.destroy();
		74	});

test/ts/TestTraits.ts +4 0

                     try {
                         await cb(t);
                     } catch (e) {
+                        // verbose error information
+                        // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
                     }

tsconfig.json +3 -1

                     "outDir" : "build/dist",
                     "declaration": true,
                     "lib": [
-                        "es2015"
+                        "es5",
+                        "es2015.promise",
+                        "es2015.symbol"
                     ]
                 },
                 "include" : [

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