@theia/filesystem 1.45.1 → 1.46.0-next.72

package/src/node/download/directory-archiver.spec.ts

@@ -1,104 +1,104 @@
-// *****************************************************************************
-// Copyright (C) 2018 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import * as fs from '@theia/core/shared/fs-extra';
-import * as path from 'path';
-import * as temp from 'temp';
-import { extract } from 'tar-fs';
-import { expect } from 'chai';
-import URI from '@theia/core/lib/common/uri';
-import { MockDirectoryArchiver } from './test/mock-directory-archiver';
-import { FileUri } from '@theia/core/lib/node/file-uri';
-
-const track = temp.track();
-
-describe('directory-archiver', () => {
-
-    after(() => {
-        track.cleanupSync();
-    });
-
-    it('should archive a directory', async function (): Promise<unknown> {
-        this.timeout(20_000);
-        const fromPath = track.mkdirSync('from');
-        fs.writeFileSync(path.join(fromPath, 'A.txt'), 'A');
-        fs.writeFileSync(path.join(fromPath, 'B.txt'), 'B');
-        expect(fs.readFileSync(path.join(fromPath, 'A.txt'), { encoding: 'utf8' })).to.be.equal('A');
-        expect(fs.readFileSync(path.join(fromPath, 'B.txt'), { encoding: 'utf8' })).to.be.equal('B');
-        const toPath = track.mkdirSync('to');
-        const archiver = new MockDirectoryArchiver();
-        await archiver.archive(fromPath, path.join(toPath, 'output.tar'));
-        expect(fs.existsSync(path.join(toPath, 'output.tar'))).to.be.true;
-        const assertPath = track.mkdirSync('assertPath');
-        return new Promise<void>(resolve => {
-            fs.createReadStream(path.join(toPath, 'output.tar')).pipe(extract(assertPath)).on('finish', () => {
-                expect(fs.readdirSync(assertPath).sort()).to.be.deep.equal(['A.txt', 'B.txt']);
-                expect(fs.readFileSync(path.join(assertPath, 'A.txt'), { encoding: 'utf8' })).to.be.equal(fs.readFileSync(path.join(fromPath, 'A.txt'), { encoding: 'utf8' }));
-                expect(fs.readFileSync(path.join(assertPath, 'B.txt'), { encoding: 'utf8' })).to.be.equal(fs.readFileSync(path.join(fromPath, 'B.txt'), { encoding: 'utf8' }));
-                resolve();
-            });
-        });
-    });
-
-    describe('findCommonParents', () => {
-        ([
-            {
-                input: ['/A/B/C/D.txt', '/X/Y/Z.txt'],
-                expected: new Map([['/A/B/C', ['/A/B/C/D.txt']], ['/X/Y', ['/X/Y/Z.txt']]]),
-                folders: ['/A', '/A/B', '/A/B/C', '/X', '/X/Y']
-            },
-            {
-                input: ['/A/B/C/D.txt', '/A/B/C/E.txt'],
-                expected: new Map([['/A/B/C', ['/A/B/C/D.txt', '/A/B/C/E.txt']]]),
-                folders: ['/A', '/A/B', '/A/B/C']
-            },
-            {
-                input: ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt'],
-                expected: new Map([['/A', ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt']]]),
-                folders: ['/A', '/A/B', '/A/B/C']
-            },
-            {
-                input: ['/A/B/C/D.txt', '/A/B/C/E.txt', '/A'],
-                expected: new Map([['/A', ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt']]]),
-                folders: ['/A', '/A/B', '/A/B/C']
-            },
-            {
-                input: ['/A/B/C/D.txt', '/A/B/X/E.txt'],
-                expected: new Map([['/A/B', ['/A/B/C/D.txt', '/A/B/X/E.txt']]]),
-                folders: ['/A', '/A/B', '/A/B/C', '/A/B/X']
-            }
-        ] as ({ input: string[], expected: Map<string, string[]>, folders?: string[] })[]).forEach(test => {
-            const { input, expected, folders } = test;
-            it(`should find the common parent URIs among [${input.join(', ')}] => [${Array.from(expected.keys()).join(', ')}]`, async () => {
-                const archiver = new MockDirectoryArchiver(folders ? folders.map(FileUri.create) : []);
-                const actual = await archiver.findCommonParents(input.map(FileUri.create));
-                expect(asString(actual)).to.be.equal(asString(expected));
-            });
-        });
-
-        function asString(map: Map<string, string[]>): string {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const obj: any = {};
-            for (const key of Array.from(map.keys()).sort()) {
-                const values = (map.get(key) || []).sort();
-                obj[new URI(key).withScheme('file').toString()] = `[${values.map(v => new URI(v).withScheme('file').toString()).join(', ')}]`;
-            }
-            return JSON.stringify(obj);
-        }
-
-    });
-
-});
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import * as fs from '@theia/core/shared/fs-extra';
+import * as path from 'path';
+import * as temp from 'temp';
+import { extract } from 'tar-fs';
+import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
+import { MockDirectoryArchiver } from './test/mock-directory-archiver';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+
+const track = temp.track();
+
+describe('directory-archiver', () => {
+
+    after(() => {
+        track.cleanupSync();
+    });
+
+    it('should archive a directory', async function (): Promise<unknown> {
+        this.timeout(20_000);
+        const fromPath = track.mkdirSync('from');
+        fs.writeFileSync(path.join(fromPath, 'A.txt'), 'A');
+        fs.writeFileSync(path.join(fromPath, 'B.txt'), 'B');
+        expect(fs.readFileSync(path.join(fromPath, 'A.txt'), { encoding: 'utf8' })).to.be.equal('A');
+        expect(fs.readFileSync(path.join(fromPath, 'B.txt'), { encoding: 'utf8' })).to.be.equal('B');
+        const toPath = track.mkdirSync('to');
+        const archiver = new MockDirectoryArchiver();
+        await archiver.archive(fromPath, path.join(toPath, 'output.tar'));
+        expect(fs.existsSync(path.join(toPath, 'output.tar'))).to.be.true;
+        const assertPath = track.mkdirSync('assertPath');
+        return new Promise<void>(resolve => {
+            fs.createReadStream(path.join(toPath, 'output.tar')).pipe(extract(assertPath)).on('finish', () => {
+                expect(fs.readdirSync(assertPath).sort()).to.be.deep.equal(['A.txt', 'B.txt']);
+                expect(fs.readFileSync(path.join(assertPath, 'A.txt'), { encoding: 'utf8' })).to.be.equal(fs.readFileSync(path.join(fromPath, 'A.txt'), { encoding: 'utf8' }));
+                expect(fs.readFileSync(path.join(assertPath, 'B.txt'), { encoding: 'utf8' })).to.be.equal(fs.readFileSync(path.join(fromPath, 'B.txt'), { encoding: 'utf8' }));
+                resolve();
+            });
+        });
+    });
+
+    describe('findCommonParents', () => {
+        ([
+            {
+                input: ['/A/B/C/D.txt', '/X/Y/Z.txt'],
+                expected: new Map([['/A/B/C', ['/A/B/C/D.txt']], ['/X/Y', ['/X/Y/Z.txt']]]),
+                folders: ['/A', '/A/B', '/A/B/C', '/X', '/X/Y']
+            },
+            {
+                input: ['/A/B/C/D.txt', '/A/B/C/E.txt'],
+                expected: new Map([['/A/B/C', ['/A/B/C/D.txt', '/A/B/C/E.txt']]]),
+                folders: ['/A', '/A/B', '/A/B/C']
+            },
+            {
+                input: ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt'],
+                expected: new Map([['/A', ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt']]]),
+                folders: ['/A', '/A/B', '/A/B/C']
+            },
+            {
+                input: ['/A/B/C/D.txt', '/A/B/C/E.txt', '/A'],
+                expected: new Map([['/A', ['/A', '/A/B/C/D.txt', '/A/B/C/E.txt']]]),
+                folders: ['/A', '/A/B', '/A/B/C']
+            },
+            {
+                input: ['/A/B/C/D.txt', '/A/B/X/E.txt'],
+                expected: new Map([['/A/B', ['/A/B/C/D.txt', '/A/B/X/E.txt']]]),
+                folders: ['/A', '/A/B', '/A/B/C', '/A/B/X']
+            }
+        ] as ({ input: string[], expected: Map<string, string[]>, folders?: string[] })[]).forEach(test => {
+            const { input, expected, folders } = test;
+            it(`should find the common parent URIs among [${input.join(', ')}] => [${Array.from(expected.keys()).join(', ')}]`, async () => {
+                const archiver = new MockDirectoryArchiver(folders ? folders.map(FileUri.create) : []);
+                const actual = await archiver.findCommonParents(input.map(FileUri.create));
+                expect(asString(actual)).to.be.equal(asString(expected));
+            });
+        });
+
+        function asString(map: Map<string, string[]>): string {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const obj: any = {};
+            for (const key of Array.from(map.keys()).sort()) {
+                const values = (map.get(key) || []).sort();
+                obj[new URI(key).withScheme('file').toString()] = `[${values.map(v => new URI(v).withScheme('file').toString()).join(', ')}]`;
+            }
+            return JSON.stringify(obj);
+        }
+
+    });
+
+});

package/src/node/download/directory-archiver.ts

@@ -1,126 +1,126 @@
-// *****************************************************************************
-// Copyright (C) 2018 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { injectable } from '@theia/core/shared/inversify';
-import * as fs from '@theia/core/shared/fs-extra';
-import { pack } from 'tar-fs';
-import URI from '@theia/core/lib/common/uri';
-import { FileUri } from '@theia/core/lib/node/file-uri';
-
-@injectable()
-export class DirectoryArchiver {
-
-    async archive(inputPath: string, outputPath: string, entries?: string[]): Promise<void> {
-        return new Promise<void>(async (resolve, reject) => {
-            pack(inputPath, { entries }).pipe(fs.createWriteStream(outputPath)).on('finish', () => resolve()).on('error', e => reject(e));
-        });
-    }
-
-    async findCommonParents(uris: URI[]): Promise<Map<string, string[]>> {
-        const map = new Map<string, string[]>();
-        for (const uri of uris) {
-            // 1. Get the container if not the URI is not a directory.
-            const containerUri = (await this.isDir(uri)) ? uri : uri.parent;
-            let containerUriStr = this.toUriString(containerUri);
-            // 2. If the container already registered, just append the current URI to it.
-            if (map.has(containerUriStr)) {
-                map.set(containerUriStr, [...map.get(containerUriStr)!, this.toUriString(uri)]);
-            } else {
-                // 3. Try to find the longest container URI that we can use.
-                // When we have `/A/B/` and `/A/C` and a file `A/B/C/D.txt` then we need to find `/A/B`. The longest URIs come first.
-                for (const knownContainerUri of Array.from(map.keys()).sort((left, right) => right.length - left.length)) {
-                    if (uri.toString().startsWith(knownContainerUri)) {
-                        containerUriStr = knownContainerUri;
-                        break;
-                    }
-                }
-                const entries = map.get(containerUriStr) || [];
-                entries.push(this.toUriString(uri));
-                map.set(containerUriStr, entries);
-            }
-            // 4. Collapse the hierarchy by finding the closest common parents for the entries, if any.
-            let collapsed = false;
-            collapseLoop: while (!collapsed) {
-                const knownContainerUris = Array.from(map.keys()).sort((left, right) => right.length - left.length);
-                if (knownContainerUris.length > 1) {
-                    for (let i = 0; i < knownContainerUris.length; i++) {
-                        for (let j = i + 1; j < knownContainerUris.length; j++) {
-                            const left = knownContainerUris[i];
-                            const right = knownContainerUris[j];
-                            const commonParent = this.closestCommonParentUri(new URI(left), new URI(right));
-                            if (commonParent && !commonParent.path.isRoot) {
-                                const leftEntries = map.get(left) || [];
-                                const rightEntries = map.get(right) || [];
-                                map.delete(left);
-                                map.delete(right);
-                                map.set(this.toUriString(commonParent), [...leftEntries, ...rightEntries]);
-                                break collapseLoop;
-                            }
-                        }
-                    }
-                }
-                collapsed = true;
-            }
-        }
-        return map;
-    }
-
-    protected closestCommonParentUri(left: URI, right: URI): URI | undefined {
-        if (left.scheme !== right.scheme) {
-            return undefined;
-        }
-        const allLeft = left.allLocations;
-        const allRight = right.allLocations;
-        for (const leftUri of allLeft) {
-            for (const rightUri of allRight) {
-                if (this.equal(leftUri, rightUri)) {
-                    return leftUri;
-                }
-            }
-        }
-        return undefined;
-    }
-
-    protected async isDir(uri: URI): Promise<boolean> {
-        try {
-            const stat = await fs.stat(FileUri.fsPath(uri));
-            return stat.isDirectory();
-        } catch {
-            return false;
-        }
-    }
-
-    protected equal(left: URI | URI[], right: URI | URI[]): boolean {
-        if (Array.isArray(left) && Array.isArray(right)) {
-            if (left === right) {
-                return true;
-            }
-            if (left.length !== right.length) {
-                return false;
-            }
-            return left.map(this.toUriString).sort().toString() === right.map(this.toUriString).sort().toString();
-        } else if (left instanceof URI && right instanceof URI) {
-            return this.toUriString(left) === this.toUriString(right);
-        }
-        return false;
-    }
-
-    protected toUriString(uri: URI): string {
-        const raw = uri.toString();
-        return raw.endsWith('/') ? raw.slice(0, -1) : raw;
-    }
-
-}
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import * as fs from '@theia/core/shared/fs-extra';
+import { pack } from 'tar-fs';
+import URI from '@theia/core/lib/common/uri';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+
+@injectable()
+export class DirectoryArchiver {
+
+    async archive(inputPath: string, outputPath: string, entries?: string[]): Promise<void> {
+        return new Promise<void>(async (resolve, reject) => {
+            pack(inputPath, { entries }).pipe(fs.createWriteStream(outputPath)).on('finish', () => resolve()).on('error', e => reject(e));
+        });
+    }
+
+    async findCommonParents(uris: URI[]): Promise<Map<string, string[]>> {
+        const map = new Map<string, string[]>();
+        for (const uri of uris) {
+            // 1. Get the container if not the URI is not a directory.
+            const containerUri = (await this.isDir(uri)) ? uri : uri.parent;
+            let containerUriStr = this.toUriString(containerUri);
+            // 2. If the container already registered, just append the current URI to it.
+            if (map.has(containerUriStr)) {
+                map.set(containerUriStr, [...map.get(containerUriStr)!, this.toUriString(uri)]);
+            } else {
+                // 3. Try to find the longest container URI that we can use.
+                // When we have `/A/B/` and `/A/C` and a file `A/B/C/D.txt` then we need to find `/A/B`. The longest URIs come first.
+                for (const knownContainerUri of Array.from(map.keys()).sort((left, right) => right.length - left.length)) {
+                    if (uri.toString().startsWith(knownContainerUri)) {
+                        containerUriStr = knownContainerUri;
+                        break;
+                    }
+                }
+                const entries = map.get(containerUriStr) || [];
+                entries.push(this.toUriString(uri));
+                map.set(containerUriStr, entries);
+            }
+            // 4. Collapse the hierarchy by finding the closest common parents for the entries, if any.
+            let collapsed = false;
+            collapseLoop: while (!collapsed) {
+                const knownContainerUris = Array.from(map.keys()).sort((left, right) => right.length - left.length);
+                if (knownContainerUris.length > 1) {
+                    for (let i = 0; i < knownContainerUris.length; i++) {
+                        for (let j = i + 1; j < knownContainerUris.length; j++) {
+                            const left = knownContainerUris[i];
+                            const right = knownContainerUris[j];
+                            const commonParent = this.closestCommonParentUri(new URI(left), new URI(right));
+                            if (commonParent && !commonParent.path.isRoot) {
+                                const leftEntries = map.get(left) || [];
+                                const rightEntries = map.get(right) || [];
+                                map.delete(left);
+                                map.delete(right);
+                                map.set(this.toUriString(commonParent), [...leftEntries, ...rightEntries]);
+                                break collapseLoop;
+                            }
+                        }
+                    }
+                }
+                collapsed = true;
+            }
+        }
+        return map;
+    }
+
+    protected closestCommonParentUri(left: URI, right: URI): URI | undefined {
+        if (left.scheme !== right.scheme) {
+            return undefined;
+        }
+        const allLeft = left.allLocations;
+        const allRight = right.allLocations;
+        for (const leftUri of allLeft) {
+            for (const rightUri of allRight) {
+                if (this.equal(leftUri, rightUri)) {
+                    return leftUri;
+                }
+            }
+        }
+        return undefined;
+    }
+
+    protected async isDir(uri: URI): Promise<boolean> {
+        try {
+            const stat = await fs.stat(FileUri.fsPath(uri));
+            return stat.isDirectory();
+        } catch {
+            return false;
+        }
+    }
+
+    protected equal(left: URI | URI[], right: URI | URI[]): boolean {
+        if (Array.isArray(left) && Array.isArray(right)) {
+            if (left === right) {
+                return true;
+            }
+            if (left.length !== right.length) {
+                return false;
+            }
+            return left.map(this.toUriString).sort().toString() === right.map(this.toUriString).sort().toString();
+        } else if (left instanceof URI && right instanceof URI) {
+            return this.toUriString(left) === this.toUriString(right);
+        }
+        return false;
+    }
+
+    protected toUriString(uri: URI): string {
+        const raw = uri.toString();
+        return raw.endsWith('/') ? raw.slice(0, -1) : raw;
+    }
+
+}

package/src/node/download/file-download-backend-module.ts

@@ -1,32 +1,32 @@
-// *****************************************************************************
-// Copyright (C) 2018 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { ContainerModule } from '@theia/core/shared/inversify';
-import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
-import { FileDownloadEndpoint } from './file-download-endpoint';
-import { FileDownloadHandler, SingleFileDownloadHandler, MultiFileDownloadHandler, DownloadLinkHandler } from './file-download-handler';
-import { DirectoryArchiver } from './directory-archiver';
-import { FileDownloadCache } from './file-download-cache';
-
-export default new ContainerModule(bind => {
-    bind(FileDownloadEndpoint).toSelf().inSingletonScope();
-    bind(BackendApplicationContribution).toService(FileDownloadEndpoint);
-    bind(FileDownloadCache).toSelf().inSingletonScope();
-    bind(FileDownloadHandler).to(SingleFileDownloadHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.SINGLE);
-    bind(FileDownloadHandler).to(MultiFileDownloadHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.MULTI);
-    bind(FileDownloadHandler).to(DownloadLinkHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.DOWNLOAD_LINK);
-    bind(DirectoryArchiver).toSelf().inSingletonScope();
-});
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
+import { FileDownloadEndpoint } from './file-download-endpoint';
+import { FileDownloadHandler, SingleFileDownloadHandler, MultiFileDownloadHandler, DownloadLinkHandler } from './file-download-handler';
+import { DirectoryArchiver } from './directory-archiver';
+import { FileDownloadCache } from './file-download-cache';
+
+export default new ContainerModule(bind => {
+    bind(FileDownloadEndpoint).toSelf().inSingletonScope();
+    bind(BackendApplicationContribution).toService(FileDownloadEndpoint);
+    bind(FileDownloadCache).toSelf().inSingletonScope();
+    bind(FileDownloadHandler).to(SingleFileDownloadHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.SINGLE);
+    bind(FileDownloadHandler).to(MultiFileDownloadHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.MULTI);
+    bind(FileDownloadHandler).to(DownloadLinkHandler).inSingletonScope().whenTargetNamed(FileDownloadHandler.DOWNLOAD_LINK);
+    bind(DirectoryArchiver).toSelf().inSingletonScope();
+});