implab/implabjs-djx Commit - r153:8ae7abbb3114

Movin the observable implementation to the class

cin -

r153:8ae7abbb3114 default

parent child

Context file:

r153:8ae7abbb3114

Collapse all files

The requested changes are too big and content was truncated. Show full diff

djx/src/main/ts/observable/ObservableImpl.ts created 644 +169 0

@@ -0,0 +1,169
	1	import { id as mid } from "module";
	2	import { AccumulatorFn, FusedProducer, Observable, Observer, OperatorFn } from "./interfaces";
	3	import { TraceSource } from "@implab/core-amd/log/TraceSource";
	4	import { scan } from "dojo/parser";
	5	import { filter } from "dojo/query";
	6
	7	const trace = TraceSource.get(mid);
	8
	9	const noop = () => { };
	10
	11	const errorFallback = (e: unknown) => trace.error("Unhandled observable error: {0}", e);
	12
	13	const sink = <T>(consumer: Observer<T>) => {
	14	// eslint-disable-next-line @typescript-eslint/unbound-method
	15	const { next, error, complete } = consumer;
	16	return {
	17	next: next ? next.bind(consumer) : noop,
	18	error: error ? error.bind(consumer) : errorFallback, // report unhandled errors
	19	complete: complete ? complete.bind(consumer) : noop
	20	};
	21	};
	22
	23	const
	24
	25	export class ObservableImpl<T> implements Observable<T> {
	26
	27	private readonly _producer: FusedProducer<T>;
	28
	29	constructor(producer: FusedProducer<T>) {
	30	this._producer = producer;
	31	}
	32
	33	subscribe(consumer: Observer<T> = {}) {
	34	return {
	35	unsubscribe: this._producer(sink(consumer)) ?? noop
	36	}
	37	}
	38
	39	map<T2>(mapper: (value: T) => T2) {
	40	return new ObservableImpl<T2>(({ next, ...rest }) =>
	41	this._producer({
	42	next: next !== noop ? (v: T) => next(mapper(v)) : noop,
	43	...rest
	44	}));
	45	}
	46
	47	tap({ next: tapNext, complete: tapComplete, error: tapError }: Observer<T>) {
	48	return new ObservableImpl<T>(({ next, complete, error }) =>
	49	this._producer({
	50	next: tapNext ? (v => (tapNext(v), next(v))) : next,
	51	complete: tapComplete ? (() => (tapComplete(), complete())) : complete,
	52	error: tapError ? (e => (tapError(e), error(e))) : error
	53	}));
	54	}
	55
	56	filter: (predicate) => _observe(({ next, ...rest }) =>
	57	producer({
	58	next: next !== noop ? (v: T) => predicate(v) ? next(v) : void (0) : noop,
	59	...rest
	60	})
	61	),
	62
	63	until: predicate => _observe(({ next, complete, ...rest }) =>
	64	producer({
	65	next: v => predicate(v) ? complete() : next(v),
	66	complete,
	67	...rest
	68	})
	69	),
	70
	71	while: predicate => _observe(({ next, complete, ...rest }) =>
	72	producer({
	73	next: v => predicate(v) ? next(v) : complete(),
	74	complete,
	75	...rest
	76	})
	77	),
	78
	79	scan: <A>(...args: [AccumulatorFn<T, A>, A] \| [AccumulatorFn<T, T>]) => _observe<T \| A>(({ next, ...rest }) => {
	80	if (args.length === 1) {
	81	const [accumulator] = args;
	82	let _acc: T;
	83	let index = 0;
	84	return producer({
	85	next: next !== noop ? (v: T) => next(index++ === 0 ? _acc = v : _acc = accumulator(_acc, v)) : noop,
	86	...rest
	87	});
	88	} else {
	89	const [accumulator, initial] = args;
	90	let _acc = initial;
	91	return producer({
	92	next: next !== noop ? (v: T) => next(_acc = accumulator(_acc, v)) : noop,
	93	...rest
	94	});
	95	}
	96	}),
	97
	98	reduce: <A>(...args: [AccumulatorFn<T, A>, A] \| [AccumulatorFn<T, T>]) => _observe<T \| A>(({ next, complete, error }) => {
	99	if (args.length === 1) {
	100	const [accumulator] = args;
	101	let _acc: T;
	102	let index = 0;
	103	return producer({
	104	next: next !== noop ? (v: T) => {
	105	_acc = index++ === 0 ? v : accumulator(_acc, v);
	106	} : noop,
	107	complete: () => {
	108	if (index === 0) {
	109	error(new Error("The sequence can't be empty"));
	110	} else {
	111	next(_acc);
	112	complete();
	113	}
	114	},
	115	error
	116	});
	117	} else {
	118	const [accumulator, initial] = args;
	119	let _acc = initial;
	120	return producer({
	121	next: next !== noop ? (v: T) => {
	122	_acc = accumulator(_acc, v);
	123	} : noop,
	124	complete: () => {
	125	next(_acc);
	126	complete();
	127	},
	128	error
	129	});
	130	}
	131	}),
	132
	133	cat: (...seq) => _observe(({ next, complete: final, ...rest }) => {
	134	let cleanup: () => void;
	135	const len = seq.length;
	136	const complete = (i: number) => i < len ?
	137	() => {
	138	const subscription = seq[i].subscribe({ next, complete: complete(i + 1), ...rest });
	139	cleanup = subscription.unsubscribe.bind(subscription);
	140	} : final;
	141
	142	cleanup = producer({ next, complete: complete(0), ...rest }) ?? noop;
	143
	144	return () => cleanup();
	145	}),
	146
	147	pipe: <U>(op: OperatorFn<T, U>) => op(_observe(producer)),
	148
	149	next: collect(
	150	producer,
	151	({ next, complete, error }) => ({
	152	next: v => (next(v), complete()),
	153	complete: () => error(new Error("The sequence is empty")),
	154	error
	155	})
	156	),
	157
	158	collect: collect(
	159	producer,
	160	({ next, complete, error }) => {
	161	const data: T[] = [];
	162	return {
	163	next: v => data.push(v),
	164	complete: () => (next(data), complete()),
	165	error
	166	};
	167	}
	168	)
	169	} No newline at end of file

djx/src/main/ts/observable/interfaces.d.ts created 644 +153 0

@@ -0,0 +1,153
	1	import { ICancellation } from "@implab/core-amd/interfaces";
	2
	3	/**
	4	* The interface for the consumer of an observable sequence
	5	*/
	6	export interface Observer<T> {
	7	/**
	8	* Called for the next element in the sequence
	9	*/
	10	next?(value: T): void;
	11
	12	/**
	13	* Called once when the error occurs in the sequence.
	14	*/
	15	error?(e: unknown): void;
	16
	17	/**
	18	* Called once at the end of the sequence.
	19	*/
	20	complete?(): void;
	21	}
	22
	23	/**
	24	* The group of functions to feed an observable. These methods are provided to
	25	* the producer to generate a stream of events.
	26	*/
	27	export type Sink<T> = {
	28	/**
	29	* Call to send the next element in the sequence
	30	*/
	31	next: (value: T) => void;
	32
	33	/**
	34	* Call to notify about the error occurred in the sequence.
	35	*/
	36	error: (e: unknown) => void;
	37
	38	/**
	39	* Call to signal the end of the sequence.
	40	*/
	41	complete: () => void;
	42
	43	/**
	44	* Checks whether the sink is accepting new elements. It's safe to
	45	* send elements to the closed sink.
	46	*/
	47	isClosed: () => boolean;
	48	};
	49
	50	export type Producer<T> = (sink: Sink<T>) => (void \| (() => void));
	51
	52	export type FusedSink<T> = Omit<Sink<T>, "isClosed">;
	53
	54	export type FusedProducer<T> = (sink: FusedSink<T>) => (void \| (() => void));
	55
	56	export interface Unsubscribable {
	57	unsubscribe(): void;
	58	}
	59
	60	export interface Subscribable<T> {
	61	/** Subscribes a consumer to events. If a consumer isn't specified
	62	* this method activates the producer to achieve side affects if any.
	63	*/
	64	subscribe(consumer?: Observer<T>): Unsubscribable;
	65	}
	66
	67	export type AccumulatorFn<T, A> = (acc: A, value: T) => A;
	68
	69	export type OperatorFn<T, U> = (source: Observable<T>) => Observable<U>;
	70
	71	/** The observable source of items. */
	72	export interface Observable<T> extends Subscribable<T> {
	73	/** Transforms elements of the sequence with the specified mapper
	74	*
	75	* @param mapper The mapper used to transform the values
	76	*/
	77	map<T2>(mapper: (value: T) => T2): Observable<T2>;
	78
	79	/** Injects the specified observer into the each producer to consumer chain.
	80	* The method is used to add side effect to the events processing.
	81	*
	82	* @param observer The consumer for the events
	83	*/
	84	tap(observer: Observer<T>): Observable<T>;
	85
	86	/** Filters elements of the sequence. The resulting sequence will
	87	* contain only elements which match the specified predicate.
	88	*
	89	* @param predicate The filter predicate.
	90	*/
	91	filter(predicate: (value: T) => boolean): Observable<T>;
	92
	93	/** Completes the sequence once the condition is met.
	94	* @param predicate The condition which should be met to complete the sequence
	95	*/
	96	until(predicate: (value: T) => boolean): Observable<T>;
	97
	98	/** Keeps the sequence running while elements satisfy the condition.
	99	*
	100	* @param predicate The condition which should be met to continue.
	101	*/
	102	while(predicate: (value: T) => boolean): Observable<T>;
	103
	104	/** Applies accumulator to each value in the sequence and
	105	* emits the accumulated value for each source element
	106	*
	107	* @param accumulator
	108	* @param initial
	109	*/
	110	scan<A>(accumulator: AccumulatorFn<T, A>, initial: A): Observable<A>;
	111	scan(accumulator: AccumulatorFn<T, T>): Observable<T>;
	112
	113	/** Applies accumulator to each value in the sequence and
	114	* emits the accumulated value at the end of the sequence
	115	*
	116	* @param accumulator
	117	* @param initial
	118	*/
	119	reduce<A>(accumulator: AccumulatorFn<T, A>, initial: A): Observable<A>;
	120	reduce(accumulator: AccumulatorFn<T, T>): Observable<T>;
	121
	122	/** Concatenates the specified sequences with this observable
	123	*
	124	* @param seq sequences to concatenate with the current observable
	125	*
	126	* The concatenation doesn't accumulate values from the specified sequences,
	127	* The result of the concatenation is the new observable which will switch
	128	* to the next observable after the previous one completes. Values emitted
	129	* before the next observable being active are lost.
	130	*/
	131	cat(...seq: Subscribable<T>[]): Observable<T>;
	132
	133
	134	/** Pipes the specified operator to produce the new observable
	135	* @param op The operator consumes this observable and produces a new one
	136	*
	137	* The operator is a higher order function which takes a source observable
	138	* and returns a producer for the new observable.
	139	*
	140	* This function can be used to create a complex mapping between source and
	141	* resulting observables. The operator may have a state (or a side effect)
	142	* and can be connected to multiple observables.
	143	*/
	144	pipe<U>(op: OperatorFn<T, U>): Observable<U>;
	145
	146	/** Waits for the next event to occur and returns a promise for the next value
	147	* @param ct Cancellation token
	148	*/
	149	next(ct?: ICancellation): Promise<T>;
	150
	151	/** Collects items of the sequence to the array. */
	152	collect(ct?: ICancellation): Promise<T[]>;
	153	} No newline at end of file

djx/src/main/ts/observable.ts +2 -152

             import { id as mid} from "module";
             import { Cancellation } from "@implab/core-amd/Cancellation";
-            import { ICancellation } from "@implab/core-amd/interfaces";
             import { TraceSource } from "@implab/core-amd/log/TraceSource";
             import { isPromise } from "@implab/core-amd/safe";
+            import { Unsubscribable, Observer, Producer, FusedSink, FusedProducer, AccumulatorFn, Observable, OperatorFn, Subscribable } from "./observable/interfaces";
-            const trace = TraceSource.get(mid);
-            /**
-             * The interface for the consumer of an observable sequence
-             */
-            export interface Observer<T> {
-                /**
-                 * Called for the next element in the sequence
-                 */
-                next?(value: T): void;
-                /**
-                 * Called once when the error occurs in the sequence.
-                 */
-                error?(e: unknown): void;
-                /**
-                 * Called once at the end of the sequence.
-                 */
-                complete?(): void;
-            /**
-             * The group of functions to feed an observable. These methods are provided to
-             * the producer to generate a stream of events.
-             */
-            export type Sink<T> = {
-                /**
-                 * Call to send the next element in the sequence
-                 */
-                next: (value: T) => void;
-                /**
-                 * Call to notify about the error occurred in the sequence.
-                 */
-                error: (e: unknown) => void;
-                /**
-                 * Call to signal the end of the sequence.
-                 */
-                complete: () => void;
-                /**
-                 * Checks whether the sink is accepting new elements. It's safe to
-                 * send elements to the closed sink.
-                 */
-                isClosed: () => boolean;
-            };
-            export type Producer<T> = (sink: Sink<T>) => (void | (() => void));
-            type FusedSink<T> = Omit<Sink<T>, "isClosed">;
-            type FusedProducer<T> = (sink: FusedSink<T>) => (void | (() => void));
-            export interface Unsubscribable {
-                unsubscribe(): void;
             export const isUnsubscribable = (v: unknown): v is Unsubscribable =>
                 v !== null && v !== undefined && typeof (v as Unsubscribable).unsubscribe === "function";
             export const isSubscribable = <T = unknown>(v: unknown): v is Subscribable<T> =>
                 v !== null && v !== undefined && typeof (v as Subscribable<unknown>).subscribe === "function";
-            export interface Subscribable<T> {
-                /** Subscribes a consumer to events. If a consumer isn't specified
-                 * this method activates the producer to achieve side affects if any.
-                 */
-                subscribe(consumer?: Observer<T>): Unsubscribable;
-            export type AccumulatorFn<T, A> = (acc: A, value: T) => A;
-            export type OperatorFn<T, U> = (source: Observable<T>) => Observable<U>;
-            /** The observable source of items. */
-            export interface Observable<T> extends Subscribable<T> {
-                /** Transforms elements of the sequence with the specified mapper
-                 * @param mapper The mapper used to transform the values
-                 */
-                map<T2>(mapper: (value: T) => T2): Observable<T2>;
-                /** Injects the specified observer into the each producer to consumer chain.
-                 * The method is used to add side effect to the events processing.
-                 * @param observer The consumer for the events
-                 */
-                tap(observer: Observer<T>): Observable<T>;
-                /** Filters elements of the sequence. The resulting sequence will
-                 * contain only elements which match the specified predicate.
-                 * @param predicate The filter predicate.
-                 */
-                filter(predicate: (value: T) => boolean): Observable<T>;
-                /** Completes the sequence once the condition is met.
-                 * @param predicate The condition which should be met to complete the sequence
-                 */
-                until(predicate: (value: T) => boolean): Observable<T>;
-                /** Keeps the sequence running while elements satisfy the condition.
-                 * @param predicate The condition which should be met to continue.
-                 */
-                while(predicate: (value: T) => boolean): Observable<T>;
-                /** Applies accumulator to each value in the sequence and
-                 * emits the accumulated value for each source element
-                 * @param accumulator
-                 * @param initial
-                 */
-                scan<A>(accumulator: AccumulatorFn<T, A>, initial: A): Observable<A>;
-                scan(accumulator: AccumulatorFn<T, T>): Observable<T>;
-                /** Applies accumulator to each value in the sequence and
-                 * emits the accumulated value at the end of the sequence
-                 * @param accumulator
-                 * @param initial
-                 */
-                reduce<A>(accumulator: AccumulatorFn<T, A>, initial: A): Observable<A>;
-                reduce(accumulator: AccumulatorFn<T, T>): Observable<T>;
-                /** Concatenates the specified sequences with this observable
-                 * @param seq sequences to concatenate with the current observable
-                 * The concatenation doesn't accumulate values from the specified sequences,
-                 * The result of the concatenation is the new observable which will switch
-                 * to the next observable after the previous one completes. Values emitted
-                 * before the next observable being active are lost.
-                 */
-                cat(...seq: Subscribable<T>[]): Observable<T>;
-                /** Pipes the specified operator to produce the new observable
-                 * @param op The operator consumes this observable and produces a new one
-                 * The operator is a higher order function which takes a source observable
-                 * and returns a producer for the new observable.
-                 * This function can be used to create a complex mapping between source and
-                 * resulting observables. The operator may have a state (or a side effect)
-                 * and can be connected to multiple observables.
-                 */
-                pipe<U>(op: OperatorFn<T, U>): Observable<U>;
-                /** Waits for the next event to occur and returns a promise for the next value
-                 * @param ct Cancellation token
-                */
-                next(ct?: ICancellation): Promise<T>;
-                /** Collects items of the sequence to the array. */
-                collect(ct?: ICancellation): Promise<T[]>;
             const noop = () => { };
-            const errorFallback = (e: unknown) => trace.error("Unhandled observable error: {0}", e);
             const sink = <T>(consumer: Observer<T>) => {
                 // eslint-disable-next-line @typescript-eslint/unbound-method
                 const { next, error, complete } = consumer;
                 return {
                     next: next ? next.bind(consumer) : noop,
                     error: error ? error.bind(consumer) : errorFallback, // report unhandled errors
                     complete: complete ? complete.bind(consumer) : noop
                 };
             };
             /** Wraps the producer to handle tear down logic and subscription management
              *
              * The resulting producer will invoke cleanup logic on error or complete events
              * and will prevent calling of any method from the sink.
              *
              * @param producer The producer to wrap
              * @returns The wrapper producer
              */
             const fuse = <T>(producer: Producer<T>) => ({ next, error, complete }: FusedSink<T>) => {
                 let done = false;
                 let cleanup = noop;
                 const _fin = <A extends unknown[]>(fn: (...args: A) => void) =>
                     (...args: A) => done ?
                         void (0) :
                         (done = true, cleanup(), fn(...args));
                 const _fin0 = () => done ? void (0) : (done = true, cleanup());
                 const safeSink = {
                     next: (value: T) => { !done && next(value); },
                     error: _fin(error),
                     complete: _fin(complete),
                     isClosed: () => done
                 };
                 // call the producer
                 cleanup = producer(safeSink) ?? noop;
                 // if the producer throws exception bypass it to the caller rather then to
                 // the sink. This is a feature.
                 // if the producer completed the sequence immediately call the cleanup in place
                 return done ? cleanup() : _fin0;
             };
             const _observe = <T>(producer: FusedProducer<T>): Observable<T> => ({
                 subscribe: (consumer: Observer<T> = {}) => ({
                     unsubscribe: producer(sink(consumer)) ?? noop
                 }),
                 map: (mapper) => _observe(({ next, ...rest }) =>
                     producer({
                         next: next !== noop ? (v: T) => next(mapper(v)) : noop,
                         ...rest
                     })
                 ),
                 tap: ({next: tapNext, complete: tapComplete, error: tapError}) => _observe(({next,complete, error}) =>
                     producer({
                         next: tapNext ? (v => (tapNext(v), next(v))) : next,
                         complete: tapComplete ? (() => (tapComplete(), complete())): complete,
                         error: tapError ? (e => (tapError(e), error(e))) : error
                     })
                 ),
                 filter: (predicate) => _observe(({ next, ...rest }) =>
                     producer({
                         next: next !== noop ? (v: T) => predicate(v) ? next(v) : void (0) : noop,
                         ...rest
                     })
                 ),
                 until: predicate => _observe(({ next, complete, ...rest }) =>
                     producer({
                         next: v => predicate(v) ? complete() : next(v),
                         complete,
                         ...rest
                     })
                 ),
                 while: predicate => _observe(({ next, complete, ...rest }) =>
                     producer({
                         next: v => predicate(v) ? next(v) : complete(),
                         complete,
                         ...rest
                     })
                 ),
                 scan: <A>(...args: [AccumulatorFn<T, A>, A] | [AccumulatorFn<T, T>]) => _observe<T | A>(({ next, ...rest }) => {
                     if (args.length === 1) {
                         const [accumulator] = args;
                         let _acc: T;
                         let index = 0;
                         return producer({
                             next: next !== noop ? (v: T) => next(index++ === 0 ? _acc = v : _acc = accumulator(_acc, v)) : noop,
                             ...rest
                         });
                     } else {
                         const [accumulator, initial] = args;
                         let _acc = initial;
                         return producer({
                             next: next !== noop ? (v: T) => next(_acc = accumulator(_acc, v)) : noop,
                             ...rest
                         });
                     }
                 }),
                 reduce: <A>(...args: [AccumulatorFn<T, A>, A] | [AccumulatorFn<T, T>]) => _observe<T | A>(({ next, complete, error }) => {
                     if (args.length === 1) {
                         const [accumulator] = args;
                         let _acc: T;
                         let index = 0;
                         return producer({
                             next: next !== noop ? (v: T) => {
                                 _acc = index++ === 0 ? v : accumulator(_acc, v);
                             } : noop,
                             complete: () => {
                                 if (index === 0) {
                                     error(new Error("The sequence can't be empty"));
                                 } else {
                                     next(_acc);
                                     complete();
                                 }
                             },
                             error
                         });
                     } else {
                         const [accumulator, initial] = args;
                         let _acc = initial;
                         return producer({
                             next: next !== noop ? (v: T) => {
                                 _acc = accumulator(_acc, v);
                             } : noop,
                             complete: () => {
                                 next(_acc);
                                 complete();
                             },
                             error
                         });
                     }
                 }),
                 cat: (...seq) => _observe(({ next, complete: final, ...rest }) => {
                     let cleanup: () => void;
                     const len = seq.length;
                     const complete = (i: number) => i < len ?
                         () => {
                             const subscription = seq[i].subscribe({ next, complete: complete(i + 1), ...rest });
                             cleanup = subscription.unsubscribe.bind(subscription);
                         } : final;
                     cleanup = producer({ next, complete: complete(0), ...rest }) ?? noop;
                     return () => cleanup();
                 }),
                 pipe: <U>(op: OperatorFn<T, U>) => op(_observe(producer)),
                 next: collect(
                     producer,
                     ({ next, complete, error }) => ({
                         next: v => (next(v), complete()),
                         complete: () => error(new Error("The sequence is empty")),
                         error
                     })
                 ),
                 collect: collect(
                     producer,
                     ({ next, complete, error}) => {
                         const data: T[] = [];
                         return {
                             next: v => data.push(v),
                             complete: () => (next(data), complete()),
                             error
                         };
                     }
                 )
             });
             const collect = <T, U>(
                 producer: FusedProducer<T>,
                 collector: (result: FusedSink<U>) => FusedSink<T>
             ) => (ct = Cancellation.none) => new Promise<U>((resolve, reject) => {
                 const fused = fuse<U>(({ next, complete, error, isClosed }) => {
                     const h = ct.register(error);
                     const cleanup = !isClosed() ?
                         producer(collector({ next, complete, error })) ?? noop :
                         noop;
                     return () => {
                         h.destroy();
                         cleanup();
                     };
                 });
                 fused({
                     next: resolve,
                     error: reject,
                     complete: noop
                 });
             });
             export const observe = <T>(producer: Producer<T>) => _observe(fuse(producer));
             /** Converts an array to the observable sequence of its elements. */
             export const ofArray = <T>(items: T[]) => _observe<T>(
                 ({ next, complete }) => (
                     items.forEach(next),
                     complete()
                 )
             );
             /** Converts a subscribable to the observable */
             export const ofSubscribable = <T>(subscribable: Subscribable<T>) =>
                 observe<T>(sink => {
                     const subscription = subscribable.subscribe(sink);
                     return () => subscription.unsubscribe();
                 });
             const of1 = <T>(item: T | PromiseLike<T>) => observe<T>(
                 ({ next, error, complete }) =>
                     isPromise(item) ?
                         void item.then(
                             v => (next(v), complete()),
                             error
                         ) :
                         (next(item), complete())
             );
             /** Converts a list of parameter values to the observable sequence. The
              * order of elements in the list will be preserved in the resulting sequence.
              */
             export const of = <T>(...items: (T | PromiseLike<T>)[]) => items.length === 1 ?
                 of1(items[0]) :
                 observe<T>(
                     ({ next, error, complete, isClosed }) => {
                         const n = items.length;
                         const _next = (start: number) => {
                             if (start > 0 && isClosed()) // when resumed
                                 return;
                             for (let i = start; i < n; i++) {
                                 const r = items[i];
                                 if (isPromise(r)) {
                                     r.then(v => (next(v), _next(i + 1)), error);
                                     return; // suspend
                                 } else {
                                     next(r);
                                 }
                             }
                             complete();
                         };
                         _next(0);
                     }
                 );
             export const empty = _observe<never>(({ complete }) => complete());

playground/package-lock.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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