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

              	<natures>
              		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
              	</natures>
+             	<filteredResources>
+             		<filter>
+             			<id>1599549685358</id>
+             			<name></name>
+             			<type>30</type>
+             			<matcher>
+             				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+             				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+             			</matcher>
+             		</filter>
+             	</filteredResources>
              </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) {
-                     const c = new Configuration<S>(this);
+                 async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
+                     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	1	import { Services } from "./services";
2	2	import { fluent } from "../di/traits";
	3	import { Box } from "./Box";
3	4
4	5	export default fluent<Services>().register({
5	6	host: it => it.value("example.com"),
6	7
7		bar2: it => Promise.all([import("./Foo"), import("./Bar")])
8		.then(([{ Foo }, { Bar }]) => it
9		.lifetime("container")
10		.override({
11		host: it2 => it2.value("simple.org"),
12		foo: it2 => it2.value(new 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		)
	8	foo: it => import("./Foo").then(({ Foo }) => it
	9	.factory(() => new Foo())
	10	),
	11
	12	box: it => it
	13	.factory($dependency => new Box($dependency("foo")))
26	14	});

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

              export interface Services {
                  foo: Foo;
-                 bar: Bar;
-                 bar2: Bar;
-                 box: Box<Bar>;
+                 box: Box<Foo>;
                  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; }>();
-                 await config.apply(container);
+                 const c1 = new 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