implab/implabjs-djx Commit - r116:aac297dda27d

added reduce() and next() methods to observable...

cin -

r116:aac297dda27d v1.6.0 default

parent child

Context file:

r116:aac297dda27d

Collapse all files

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

.vscode/launch.json created 644 +19 0

@@ -0,0 +1,19
	1	{
	2	// Используйте IntelliSense, чтобы узнать о возможных атрибутах.
	3	// Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов.
	4	// Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387
	5	"version": "0.2.0",
	6	"configurations": [
	7	{
	8	"type": "node",
	9	"request": "launch",
	10	"name": "Launch tests",
	11	"skipFiles": [
	12	"<node_internals>/**"
	13	],
	14	"program": "${workspaceFolder}/djx/build/test/index.js",
	15	"cwd": "${workspaceFolder}/djx/build/test",
	16	"console": "integratedTerminal"
	17	}
	18	]
	19	} No newline at end of file

djx/src/main/ts/store.ts created 644 +58 0

@@ -0,0 +1,58
	1	import { PromiseOrValue } from "@implab/core-amd/interfaces";
	2	import { isPromise } from "@implab/core-amd/safe";
	3	import { observe, Observable } from "./observable";
	4
	5	export interface OrderedUpdate<T> {
	6	/** The item is being updated */
	7	readonly item: T;
	8
	9	/** The previous index of the item, -1 in case it is inserted */
	10	readonly prevIndex: number;
	11
	12	/** The new index of the item, -1 in case it is deleted */
	13	readonly newIndex: number;
	14
	15	}
	16
	17	export type QueryResults<T> = Observable<OrderedUpdate<T>>;
	18
	19	interface DjObservableResults<T> {
	20	/**
	21	* Allows observation of results
	22	*/
	23	observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
	24	remove(): void;
	25	};
	26	}
	27
	28	interface Queryable<T, A extends unknown[]> {
	29	query(...args: A): PromiseOrValue<T[]>;
	30	}
	31
	32	export const isObservableResults = <T>(v: object): v is DjObservableResults<T> =>
	33	v && (typeof (v as { observe?: unknown; }).observe === "function");
	34
	35	export const query = <T, A extends unknown[]>(store: Queryable<T, A>, includeUpdates = true) =>
	36	(...args: A) => {
	37	return observe<OrderedUpdate<T>>(({ next, complete, error, isClosed }) => {
	38	try {
	39	const results = store.query(...args);
	40	if (isPromise(results)) {
	41	results.then(items => items.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 })))
	42	.then(undefined, error);
	43	} else {
	44	results.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 }));
	45	}
	46
	47	if (!isClosed() && isObservableResults<T>(results)) {
	48	const h = results.observe((item, prevIndex, newIndex) => next({ item, prevIndex, newIndex }), includeUpdates);
	49	return () => h.remove();
	50	} else {
	51	complete();
	52	}
	53	} catch (err) {
	54	error(err);
	55	}
	56	});
	57
	58	};

djx/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

djx/package.json +2 -2

             {
                 "name": "@implab/djx",
                 "version": "0.0.1-dev",
                 "description": "Supports using dojo version 1 with typescript and .tsx files",
                 "keywords": [
                     "dojo",
                     "tsx",
                     "typescript",
                     "widgets"
                 ],
                 "author": "Implab team",
                 "license": "BSD-2-Clause",
                 "repository": "https://code.implab.org/implab/implabjs-djx",
                 "publishConfig": {
                     "access": "public"
                 },
                 "peerDependencies": {
-                    "@implab/core-amd": "^1.4.0",
+                    "@implab/core-amd": "^1.4.6",
                     "dojo": "^1.10.0"
                 },
                 "devDependencies": {
-                    "@implab/core-amd": "^1.4.0",
+                    "@implab/core-amd": "^1.4.6",
                     "@types/chai": "4.1.3",
                     "@types/requirejs": "2.1.31",
                     "@types/yaml": "1.2.0",
                     "@types/tap": "15.0.7",
                     "rxjs": "7.5.6",
                     "dojo": "1.16.0",
                     "@implab/dojo-typings": "1.0.3",
                     "@typescript-eslint/eslint-plugin": "^5.23.0",
                     "@typescript-eslint/parser": "^5.23.0",
                     "eslint": "^8.23.0",
                     "eslint-config-standard": "^17.0.0",
                     "eslint-plugin-import": "^2.26.0",
                     "eslint-plugin-n": "^15.2.0",
                     "eslint-plugin-promise": "^6.0.0",
                     "eslint-plugin-react": "^7.29.4",
                     "requirejs": "2.3.6",
                     "typescript": "4.8.3",
                     "yaml": "~1.7.2",
                     "tap": "16.3.0"
                 }
             }

djx/src/main/ts/observable.ts +127 -54

-            import { PromiseOrValue } from "@implab/core-amd/interfaces";
+            import { Cancellation } from "@implab/core-amd/Cancellation";
-            import { isPromise } from "@implab/core-amd/safe";
+            import { ICancellation } from "@implab/core-amd/interfaces";
             /**
              * 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));
             export interface Unsubscribable {
                 unsubscribe(): void;
             }
             export const isUnsubsribable = (v: unknown): v is Unsubscribable =>
                 v !== null && v !== undefined && typeof (v as Unsubscribable).unsubscribe === "function";
             export const isSubsribable = <T = unknown>(v: unknown): v is Subscribable<T> =>
                 v !== null && v !== undefined && typeof (v as Subscribable<unknown>).subscribe === "function";
             export interface Subscribable<T> {
                 subscribe(consumer: Partial<Observer<T>>): Unsubscribable;
             }
+            export type AccumulatorFn<T, A> = (acc: A, value: T) => A;
             /** 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>;
                 /** 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>;
                 /** Applies accumulator to each value in the sequence and
                  * emits the accumulated value for each source element
                  *
                  * @param accumulator
                  * @param initial
                  */
-                scan<A>(accumulator: (acc: A, value: T) => A, initial: A): Observable<A>;
+                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
+                 */
                 cat(...seq: Subscribable<T>[]): Observable<T>;
-                pipe<U>(f: (source: Observable<T>) => Producer<U>): Observable<U>;
+                /** Pipes the specified operator to produce the new observable
+                 * @param op The operator which consumes this observable and produces a new one
+                 */
+                pipe<U>(op: (source: Observable<T>) => Producer<U>): Observable<U>;
+                /** Waits for the next event to occur and returns a promise for the next value
+                 * @param ct Cancellation token to
+                */
+                next(ct?: ICancellation): Promise<T>;
             }
             const noop = () => { };
             const sink = <T>(consumer: Partial<Observer<T>>) => {
                 const { next, error, complete } = consumer;
                 return {
                     next: next ? next.bind(consumer) : noop,
                     error: error ? error.bind(consumer) : noop,
                     complete: complete ? complete.bind(consumer) : noop,
                     isClosed: () => false
                 };
             };
             /** Wraps the producer to handle tear down logic and subscription management
              *
              * @param producer The producer to wrap
              * @returns The wrapper producer
              */
             const fuse = <T>(producer: Producer<T>) => ({ next, error, complete }: Sink<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 safeSink = {
                     next: (value: T) => { !done && next(value); },
                     error: _fin(error),
                     complete: _fin(complete),
                     isClosed: () => done
                 };
                 cleanup = producer(safeSink) ?? noop;
                 return done ?
                     (cleanup(), noop) :
                     _fin(noop);
             };
             const _observe = <T>(producer: Producer<T>): Observable<T> => ({
                 subscribe: (consumer: Partial<Observer<T>>) => ({
                     unsubscribe: producer(sink(consumer)) ?? noop
                 }),
                 map: (mapper) => _observe(({ next, ...rest }) =>
                     producer({
                         next: next !== noop ? (v: T) => next(mapper(v)) : noop,
                         ...rest
                     })
                 ),
                 filter: (predicate) => _observe(({ next, ...rest }) =>
                     producer({
                         next: next !== noop ? (v: T) => predicate(v) ? next(v) : void (0) : noop,
                         ...rest
                     })
                 ),
-                scan: (accumulator, initial) => _observe(({ next, ...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, ...rest }) => {
+                    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,
+                            ...rest
+                        });
+                    } 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,
+                            ...rest
+                        });
+                    }
                 }),
                 cat: (...seq) => _observe(({ next, complete: final, ...rest }) => {
                     let cleanup: () => void;
                     const complete = () => {
                         const continuation = seq.shift();
                         if (continuation) {
                             // if we have a next sequence, subscribe to it
                             const subscription = continuation.subscribe({ next, complete, ...rest });
                             cleanup = subscription.unsubscribe.bind(subscription);
                         } else {
                             // otherwise notify the consumer about completion
                             final();
                         }
                     };
                     cleanup = producer({ next, complete, ...rest }) ?? noop;
                     return () => cleanup();
                 }),
-                pipe: <U>(f: (source: Observable<T>) => Producer<U>) => observe(f(_observe(producer)))
+                pipe: <U>(op: (source: Observable<T>) => Producer<U>) => observe(op(_observe(producer))),
+                next: (ct?: ICancellation) => {
+                    const _ct = ct ?? Cancellation.none;
+                    return new Promise<T>((resolve, reject) => {
+                        // wrap the producer to handle only single event
+                        const once = fuse<T>(({ next, complete, error, isClosed }) => {
+                            const h = _ct.register(error);
+                            // is the _ct fires it will call error() and isClosed() will return true
+                            const cleanup = !isClosed() ?
+                                producer({
+                                    next: v => (next(v), complete()),
+                                    complete: () => error(new Error("The sequence is empty")),
+                                    error,
+                                    isClosed
+                                }) ?? noop :
+                                noop;
+                            return () => {
+                                h.destroy();
+                                cleanup();
+                            };
                         });
-            export interface OrderUpdate<T> {
+                        once({
-                /** The item is being updated */
+                            next: resolve,
-                item: T;
+                            error: reject,
+                            complete: noop,
-                /** The previous index of the item, -1 in case it is inserted */
+                            isClosed: () => false
-                prevIndex: number;
+                        });
+                    });
-                /** The new index of the item, -1 in case it is deleted */
-                newIndex: number;
                 }
+            });
-            interface ObservableResults<T> {
-                /**
-                 * Allows observation of results
-                 */
-                observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
-                    remove(): void;
-                };
-            interface Queryable<T, A extends unknown[]> {
-                query(...args: A): PromiseOrValue<T[]>;
-            export const isObservableResults = <T>(v: object): v is ObservableResults<T> =>
-                v && (typeof (v as { observe?: unknown; }).observe === "function");
             export const observe = <T>(producer: Producer<T>) => _observe(fuse(producer));
-            export const empty = observe<never>(({ complete }) => complete());
+            export const streamArray = <T>(items: T[]) => _observe<T>(
+                ({ next, complete }) => (
+                    items.forEach(next),
+                    complete()
+                )
+            );
-            export const query = <T, A extends unknown[]>(store: Queryable<T, A>) =>
+            export const streamPromise = <T>(promise: PromiseLike<T>) => observe<T>(
-                (...args: A) => {
+                ({next, error, complete}) => void promise.then(v => (next(v), complete()), error)
-                    return observe<OrderUpdate<T>>(({ next, complete, error }) => {
+            );
-                        try {
-                            const results = store.query(...args);
-                            if (isPromise(results)) {
-                                results.then(items => items.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 })))
-                                    .then(undefined, error);
-                            } else {
-                                results.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 }));
-                            if (isObservableResults<T>(results)) {
+            export const of = <T>(...items: T[]) => _observe<T>(
-                                const h = results.observe((item, prevIndex, newIndex) => next({ item, prevIndex, newIndex }));
+                ({ next, complete }) => (
-                                return () => h.remove();
+                    items.forEach(next),
-                            } else {
+                    complete()
-                                complete();
+            );
-                        } catch (err) {
-                            error(err);
-                    });
-                };
+            export const empty = _observe<never>(({ complete }) => complete());
  No newline at end of file

djx/src/main/ts/tsx.ts +3 -2

             import { Constructor } from "@implab/core-amd/interfaces";
             import { HtmlRendition } from "./tsx/HtmlRendition";
             import { WidgetRendition } from "./tsx/WidgetRendition";
             import { isElementNode, isWidget, isWidgetConstructor, Rendition } from "./tsx/traits";
             import { FunctionRendition } from "./tsx/FunctionRendition";
             import Stateful = require("dojo/Stateful");
             import _WidgetBase = require("dijit/_WidgetBase");
             import { DjxWidgetBase } from "./tsx/DjxWidgetBase";
             import { WatchRendition } from "./tsx/WatchRendition";
-            import { Observable, observe, OrderUpdate, Subscribable } from "./observable";
+            import { Observable, observe, Subscribable } from "./observable";
             import djAttr = require("dojo/dom-attr");
             import djClass = require("dojo/dom-class");
             import { AnimationAttrs, WatchForRendition } from "./tsx/WatchForRendition";
+            import { OrderedUpdate } from "./store";
             export function createElement<T extends Constructor | string | ((props: object) => Element)>(elementType: T, ...args: unknown[]): Rendition {
                 if (typeof elementType === "string") {
                     const ctx = new HtmlRendition(elementType);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else if (isWidgetConstructor(elementType)) {
                     const ctx = new WidgetRendition(elementType);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else if (typeof elementType === "function") {
                     const ctx = new FunctionRendition(elementType as (props: unknown) => Element);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else {
                     throw new Error(`The element type '${String(elementType)}' is unsupported`);
                 }
             }
             export interface EventDetails<T = unknown> {
                 detail: T;
             }
             export interface EventSelector {
                 selectorTarget: HTMLElement;
                 target: HTMLElement;
             }
             export type DojoMouseEvent<T = unknown> = MouseEvent & EventSelector & EventDetails<T>;
             type StatefulProps<T> = T extends Stateful<infer A> ? A :
                 T extends _WidgetBase ? T : never;
             /**
              * Observers the property and calls render callback each change.
              *
              * @param target The target object which property will be observed.
              * @param prop The name of the property.
              * @param render The callback which will be called every time the value is changed
              * @returns Rendition which is created instantly
              */
             export function watch<W extends _WidgetBase, K extends keyof W>(
                 target: W,
                 prop: K,
                 render: (model: W[K]) => unknown
             ): Rendition;
             /**
              * Observers the property and calls render callback each change.
              *
              * @param target The target object which property will be observed.
              * @param prop The name of the property.
              * @param render The callback which will be called every time the value is changed
              * @returns Rendition which is created instantly
              */
             export function watch<T extends Stateful, K extends keyof StatefulProps<T>>(
                 target: T,
                 prop: K,
                 render: (model: StatefulProps<T>[K]) => unknown
             ): Rendition;
             export function watch<V>(subj: Subscribable<V>, render: (model: V) => unknown): Rendition;
             export function watch(
                 ...args: [Stateful, string, (model: unknown) => unknown] |
                     [Subscribable<unknown>, (model: unknown) => unknown]
             ) {
                 if (args.length === 3) {
                     const [target, prop, render] = args;
                     return new WatchRendition(
                         render,
                         observe(({next}) => {
                             const h = target.watch(
                                 prop,
                                 (_prop, oldValue, newValue) => oldValue !== newValue && next(newValue)
                             );
                             next(target.get(prop));
                             return () => h.remove();
                         })
                     );
                 } else {
                     const [subj, render] = args;
                     return new WatchRendition(render, subj);
                 }
             }
-            export const watchFor = <T>(source: T[] | Subscribable<OrderUpdate<T>>, render: (item: T, index: number) => unknown, opts:  AnimationAttrs = {}) => {
+            export const watchFor = <T>(source: T[] | Subscribable<OrderedUpdate<T>>, render: (item: T, index: number) => unknown, opts:  AnimationAttrs = {}) => {
                 return new WatchForRendition({
                     ...opts,
                     subject: source,
                     component: render
                 });
             };
             export const prop: {
                 <T extends Stateful, K extends string & keyof StatefulProps<T>>(target: T, name: K): Observable<StatefulProps<T>[K]>;
                 <T extends _WidgetBase, K extends keyof T>(target: T, name: K): Observable<T[K]>;
             } = (target: Stateful, name: string) => {
                 return observe(({next}) => {
                     const h = target.watch(
                         name,
                         (_prop, oldValue, newValue) => oldValue !== newValue && next(newValue)
                     );
                     next(target.get(name));
                     return () => h.remove();
                 });
             };
             export const attach = <W extends DjxWidgetBase, K extends keyof W>(target: W, name: K) => (v: W[K]) => target.set(name, v);
             export const bind = <K extends string, T>(attr: K, subj: Subscribable<T>) => {
                 let h = { unsubscribe() { } };
                 return (el: Element | { set(name: K, value: T): void; } | undefined) => {
                     if (el) {
                         if (isElementNode(el)) {
                             h = subj.subscribe({
                                 next: value => djAttr.set(el, attr, value)
                             });
                         } else {
                             h = subj.subscribe({
                                 next: value => el.set(attr, value)
                             });
                         }
                     } else {
                         h.unsubscribe();
                     }
                 };
             };
             export const toggleClass = (className: string, subj: Subscribable<boolean>) => {
                 let h = { unsubscribe() { } };
                 return (elOrWidget: HTMLElement | _WidgetBase | undefined) => {
                     const el = isWidget(elOrWidget) ? elOrWidget.domNode : elOrWidget;
                     if (el) {
                         h = subj.subscribe({
                             next: v => djClass.toggle(el, className, v)
                         });
                     } else {
                         h.unsubscribe();
                     }
                 };
             };
             export const all = <T, A extends JSX.Ref<T>[]>(...cbs: A): JSX.Ref<T> => (arg: T | undefined) => cbs.forEach(cb => cb(arg));
             /** Decorates the method which will be registered as the handle for the specified event.
              * This decorator can be applied to DjxWidgetBase subclass methods.
              *
              * ```
              *  @on("click")
              *  _onClick(eventObj: MouseEvent) {
              *      // ...
              *  }
              * ```
              */
             export const on = <E extends string>(...eventNames: E[]) =>
                 <K extends string,
                     T extends DjxWidgetBase<object, { [p in E]: EV }>,
                     EV extends Event
                 >(
                     target: T,
                     key: K,
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     _descriptor: TypedPropertyDescriptor<(eventObj: EV) => void> | TypedPropertyDescriptor<() => void>
                 ) => {
                     const handlers = eventNames.map(eventName => ({ eventName, handlerMethod: key }));
                     target._eventHandlers = target._eventHandlers ? target._eventHandlers.concat(handlers) : handlers;
                 };

djx/src/main/ts/tsx/WatchForRendition.ts 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

djx/src/test/ts/observable-tests.ts 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

djx/src/tsconfig.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

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

playground/src/main/ts/model/Appointment.ts 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

playground/src/main/ts/model/MainContext.ts 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

playground/src/main/ts/model/MainModel.ts 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

playground/src/main/ts/view/MainWidget.tsx 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