implab/implabjs-core Commit - r136:17c7de5d346c

tests

cin -

r136:17c7de5d346c ioc ts support

parent child

Context file:

r136:17c7de5d346c

Collapse all files

.project +11 0

@@ -14,4 +14,15
14	<natures>	14	<natures>
15	<nature>org.eclipse.buildship.core.gradleprojectnature</nature>	15	<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
16	</natures>	16	</natures>
		17	<filteredResources>
		18	<filter>
		19	<id>1599549685358</id>
		20	<name></name>
		21	<type>30</type>
		22	<matcher>
		23	<id>org.eclipse.core.resources.regexFilterMatcher</id>
		24	<arguments>node_modules\|.git\|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
		25	</matcher>
		26	</filter>
		27	</filteredResources>
17	</projectDescription>	28	</projectDescription>

src/main/ts/di/Configuration.ts +3 -2

                     );
                 }
-                async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
+                async applyConfiguration(data: RegistrationMap<S>, opts: { contextRequire?: any; baseModule?: string }, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
+                    const _opts = opts || {};
-                    await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
+                    await this._applyConfiguration(data, await makeResolver(_opts.baseModule, _opts.contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {

src/main/ts/di/Container.ts +16 -6

                 /**
                  * @param{String|Object} config
-                 *  The configuration of the contaier. Can be either a string or an object,
+                 *  The configuration of the container. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
-                 *  services which will be registed in the contaier.
+                 *  services which will be registered in the container.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
-                async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
+                async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
-                    const c = new Configuration<S>(this);
+                    const _opts = Object.create(opts || null);
                     if (typeof (config) === "string") {
-                        return c.loadConfiguration(config, opts && opts.contextRequire, ct);
+                        _opts.baseModule = config;
+                        const module = await import(config);
+                        if (module && module.default && typeof (module.default.apply) === "function")
+                            return module.default.apply(this);
+                        else
+                            return this._applyLegacyConfig(module, _opts, ct);
                     } else {
-                        return c.applyConfiguration(config, opts && opts.contextRequire, ct);
+                        return this._applyLegacyConfig(config, _opts, ct);
                     }
                 }
+                async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
+                    return new Configuration<S>(this).applyConfiguration(config, opts);
+                }
                 async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
                     await new FluentConfiguration<S>().register(config).apply(this, ct);
                     return this;

src/main/ts/di/fluent/FluentConfiguration.ts +7 -5

                     return this;
                 }
-                apply(target: Container<S>, ct = Cancellation.none) {
+                apply<SC extends object>(target: Container<SC>, ct = Cancellation.none) {
                     let pending = 1;
-                    return new Promise((resolve, reject) => {
+                    const _t2 = target as unknown as Container<SC & S>;
+                    return new Promise<Container<SC & S>>((resolve, reject) => {
                         function guard(v: void | Promise<void>) {
                             if (isPromise(v))
                                 v.catch(reject);
                         function complete() {
                             if (!--pending)
-                                resolve();
+                                resolve(_t2);
                         }
                         each(this._builders, (v, k) => {
                             pending++;
-                            const d = new DescriptorBuilder<S, any>(target,
+                            const d = new DescriptorBuilder<SC & S, any>(_t2,
                                 result => {
-                                    target.register(k, result);
+                                    _t2.register(k, result);
                                     complete();
                                 },
                                 reject

src/test/ts/mock/config.ts +7 -19

@@ -1,26 +1,14
1	import { Services } from "./services";	1	import { Services } from "./services";
2	import { fluent } from "../di/traits";	2	import { fluent } from "../di/traits";
		3	import { Box } from "./Box";
3		4
4	export default fluent<Services>().register({	5	export default fluent<Services>().register({
5	host: it => it.value("example.com"),	6	host: it => it.value("example.com"),
6		7
7	bar2: it => Promise.all([import("./Foo"), import("./Bar")])	8	foo: it => import("./Foo").then(({ Foo }) => it
8	.then(([{ Foo }, { Bar }]) => it	9	.factory(() => new Foo())
9	.lifetime("container")	10	),
10	.override({	11
11	host: it2 => it2.value("simple.org"),	12	box: it => it
12	foo: it2 => it2.value(new Foo())	13	.factory($dependency => new Box($dependency("foo")))
13	})
14	.factory(resolve => {
15	const bar = new Bar({
16	foo: new Foo(),
17	nested: {
18	lazy: resolve("foo", { lazy: true })
19	},
20	host: resolve("host")
21	}, "some text");
22	bar.setName(resolve("host"));
23	return bar;
24	})
25	)
26	});	14	});

src/test/ts/mock/services.ts +1 -5

             export interface Services {
                 foo: Foo;
-                bar: Bar;
+                box: Box<Foo>;
-                bar2: Bar;
-                box: Box<Bar>;
                 host: string;

src/test/ts/tests/FluentContainerTests.ts +11 -2

             import { Foo } from "../mock/Foo";
             import { Box } from "../mock/Box";
             import { delay } from "../safe";
+            import { Services } from "../mock/services";
             test("Simple fluent config", async t => {
                 const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
                         foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
                     });
-                const container = new Container<{ host: string; bar: Bar; foo: Foo; }>();
+                const c1 = new Container<{}>();
-                await config.apply(container);
+                const container = await config.apply(c1);
                 t.equal(container.resolve("host"), "example.com", "The value should be resolved");
                 t.assert(container.resolve("bar"), "The service should de activated");
                     t.equal(e.message, "bad override", "the error should pass");
                 }
             });
+            test("Load fluent config", async t => {
+                const container = new Container<Services>();
+                await container.configure("../mock/config", { contextRequire: require });
+                t.assert(container.resolve("host"), "Should resolve simple value");
+            });

src/testCjs/ts/tests/plan.ts +1 0

             import "./ContainerTests";
             import "./SafeTests";
             import "./TextTests";
+            import "./FluentContainerTests";

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