From d06f799bff62ad198973da46a2b26008f9368a0a Mon Sep 17 00:00:00 2001 From: "Remo H. Jansen" Date: Mon, 20 Jun 2016 10:57:57 +0100 Subject: [PATCH] Implemented #242 (#254) --- README.md | 41 +- gulpfile.js | 24 +- package.json | 2 +- src/annotation/decorator_utils.ts | 33 +- src/annotation/inject.ts | 2 - src/annotation/injectable.ts | 2 - src/annotation/multi_inject.ts | 2 - src/annotation/named.ts | 2 - src/annotation/property_injectors.ts | 18 +- src/annotation/tagged.ts | 2 - src/annotation/target_name.ts | 2 - src/bindings/binding.ts | 23 +- src/bindings/binding_count.ts | 2 - src/bindings/binding_scope.ts | 2 - src/bindings/binding_type.ts | 2 - src/constants/error_msgs.ts | 6 +- src/constants/metadata_keys.ts | 2 - src/interfaces/annotations/symbol.d.ts | 15 - src/interfaces/bindings/binding.d.ts | 17 - src/interfaces/bindings/factory.d.ts | 5 - src/interfaces/bindings/factory_creator.d.ts | 5 - src/interfaces/bindings/newable.d.ts | 5 - src/interfaces/bindings/provider.d.ts | 5 - src/interfaces/bindings/provider_creator.d.ts | 5 - src/interfaces/globals.d.ts | 46 + src/interfaces/interfaces.d.ts | 46 - src/interfaces/interfaces.ts | 216 +++ src/interfaces/kernel/clonable.d.ts | 3 - src/interfaces/kernel/kernel.d.ts | 19 - src/interfaces/kernel/kernel_module.d.ts | 10 - src/interfaces/kernel/kernel_snapshot.d.ts | 4 - src/interfaces/kernel/key_value_pair.d.ts | 4 - src/interfaces/kernel/lookup.d.ts | 7 - src/interfaces/kernel/map.d.ts | 17 - src/interfaces/kernel/weakmap.d.ts | 16 - src/interfaces/middleware/middleware.d.ts | 14 - src/interfaces/planning/context.d.ts | 12 - src/interfaces/planning/metadata.d.ts | 4 - src/interfaces/planning/plan.d.ts | 7 - src/interfaces/planning/planner.d.ts | 10 - src/interfaces/planning/queryable_string.d.ts | 7 - src/interfaces/planning/request.d.ts | 29 - src/interfaces/planning/target.d.ts | 16 - src/interfaces/resolution/resolver.d.ts | 5 - src/interfaces/syntax/binding_in_syntax.d.ts | 5 - .../syntax/binding_in_when_on_syntax.d.ts | 3 - src/interfaces/syntax/binding_on_syntax.d.ts | 5 - src/interfaces/syntax/binding_to_syntax.d.ts | 12 - .../syntax/binding_when_on_syntax.d.ts | 3 - .../syntax/binding_when_syntax.d.ts | 18 - src/inversify.ts | 2 - src/kernel/kernel.ts | 73 +- src/kernel/kernel_module.ts | 9 +- src/kernel/kernel_snapshot.ts | 14 +- src/kernel/key_value_pair.ts | 4 +- src/kernel/lookup.ts | 19 +- src/planning/context.ts | 13 +- src/planning/metadata.ts | 4 +- src/planning/plan.ts | 10 +- src/planning/planner.ts | 45 +- src/planning/queryable_string.ts | 4 +- src/planning/request.ts | 32 +- src/planning/target.ts | 21 +- src/resolution/resolver.ts | 15 +- src/syntax/binding_in_syntax.ts | 11 +- src/syntax/binding_in_when_on_syntax.ts | 47 +- src/syntax/binding_on_syntax.ts | 11 +- src/syntax/binding_to_syntax.ts | 25 +- src/syntax/binding_when_on_syntax.ts | 43 +- src/syntax/binding_when_syntax.ts | 59 +- src/syntax/constraint_helpers.ts | 13 +- test/annotation/inject.test.ts | 65 +- test/annotation/injectable.test.ts | 14 +- test/annotation/multi_inject.test.ts | 47 +- test/annotation/named.test.ts | 41 +- test/annotation/property_injectors.test.ts | 50 +- test/annotation/tagged.test.ts | 65 +- test/annotation/target_name.test.ts | 16 +- test/bindings/binding.test.ts | 2 - test/inversify.test.ts | 1535 +++++++++-------- test/kernel/kernel.test.ts | 207 ++- test/kernel/kernel_module.test.ts | 5 +- test/kernel/key_value_pair.test.ts | 2 - test/kernel/lookup.test.ts | 23 +- test/middleware/middleware.test.ts | 145 +- test/planning/context.test.ts | 6 +- test/planning/metadata.test.ts | 2 - test/planning/plan.test.ts | 2 - test/planning/planner.test.ts | 369 ++-- test/planning/queryable_string.test.ts | 2 - test/planning/request.test.ts | 62 +- test/planning/target.test.ts | 50 +- test/resolution/resolver.test.ts | 753 ++++---- test/syntax/binding_in_syntax.test.ts | 18 +- test/syntax/binding_in_when_on_syntax.test.ts | 51 +- test/syntax/binding_on_syntax.test.ts | 23 +- test/syntax/binding_to_syntax.test.ts | 41 +- test/syntax/binding_when_on_syntax.test.ts | 43 +- test/syntax/binding_when_syntax.test.ts | 293 ++-- test/utils/guid.test.ts | 2 - test/utils/stubs.ts | 54 +- tsconfig.json | 9 +- wiki/activation_handler.md | 28 +- wiki/architecture.md | 2 +- wiki/auto_factory.md | 16 +- wiki/circular_dependencies.md | 2 +- wiki/classes_as_id.md | 2 +- wiki/constructor_injection.md | 14 +- wiki/contextual_bindings.md | 68 +- wiki/custom_tag_decorators.md | 10 +- wiki/factory_injection.md | 37 +- wiki/get_all_named_tagged.md | 44 +- wiki/inheritance.md | 43 +- wiki/kernel_modules.md | 11 +- wiki/kernel_snapshots.md | 16 +- wiki/middleware.md | 18 +- wiki/multi_injection.md | 32 +- wiki/named_bindings.md | 31 +- wiki/oo_design.md | 32 +- wiki/property_injection.md | 42 +- wiki/provider_injection.md | 22 +- wiki/purpose.md | 41 +- wiki/recipes.md | 22 +- wiki/scope.md | 5 +- wiki/symbols_as_id.md | 26 +- wiki/tagged_bindings.md | 32 +- wiki/upgrade.md | 22 +- wiki/value_injection.md | 4 +- 128 files changed, 2903 insertions(+), 2952 deletions(-) delete mode 100644 src/interfaces/annotations/symbol.d.ts delete mode 100644 src/interfaces/bindings/binding.d.ts delete mode 100644 src/interfaces/bindings/factory.d.ts delete mode 100644 src/interfaces/bindings/factory_creator.d.ts delete mode 100644 src/interfaces/bindings/newable.d.ts delete mode 100644 src/interfaces/bindings/provider.d.ts delete mode 100644 src/interfaces/bindings/provider_creator.d.ts create mode 100644 src/interfaces/globals.d.ts delete mode 100644 src/interfaces/interfaces.d.ts create mode 100644 src/interfaces/interfaces.ts delete mode 100644 src/interfaces/kernel/clonable.d.ts delete mode 100644 src/interfaces/kernel/kernel.d.ts delete mode 100644 src/interfaces/kernel/kernel_module.d.ts delete mode 100644 src/interfaces/kernel/kernel_snapshot.d.ts delete mode 100644 src/interfaces/kernel/key_value_pair.d.ts delete mode 100644 src/interfaces/kernel/lookup.d.ts delete mode 100644 src/interfaces/kernel/map.d.ts delete mode 100644 src/interfaces/kernel/weakmap.d.ts delete mode 100644 src/interfaces/middleware/middleware.d.ts delete mode 100644 src/interfaces/planning/context.d.ts delete mode 100644 src/interfaces/planning/metadata.d.ts delete mode 100644 src/interfaces/planning/plan.d.ts delete mode 100644 src/interfaces/planning/planner.d.ts delete mode 100644 src/interfaces/planning/queryable_string.d.ts delete mode 100644 src/interfaces/planning/request.d.ts delete mode 100644 src/interfaces/planning/target.d.ts delete mode 100644 src/interfaces/resolution/resolver.d.ts delete mode 100644 src/interfaces/syntax/binding_in_syntax.d.ts delete mode 100644 src/interfaces/syntax/binding_in_when_on_syntax.d.ts delete mode 100644 src/interfaces/syntax/binding_on_syntax.d.ts delete mode 100644 src/interfaces/syntax/binding_to_syntax.d.ts delete mode 100644 src/interfaces/syntax/binding_when_on_syntax.d.ts delete mode 100644 src/interfaces/syntax/binding_when_syntax.d.ts diff --git a/README.md b/README.md index 753d97bae..12ee83ee4 100644 --- a/README.md +++ b/README.md @@ -51,14 +51,9 @@ InversifyJS has been developed with 4 main goals: ### Installation You can get the latest release and the type definitions using npm: -``` -npm install inversify@2.0.0-beta.8 inversify-dts reflect-metadata --save -``` - -The InversifyJS type definitions are included in the inversify-dts npm package: -```ts -/// +``` +npm install inversify@2.0.0-beta.9 @types/inversify reflect-metadata --save ``` The reflect-metadata type definitions are included in the npm package: @@ -106,16 +101,16 @@ This means that we should "depend upon Abstractions and do not depend upon concr Let's start by declaring some interfaces (abstractions). ```ts -interface INinja { +interface Ninja { fight(): string; sneak(): string; } -interface IKatana { +interface Katana { hit(): string; } -interface IShuriken { +interface Shuriken { throw(): string; } ``` @@ -123,7 +118,7 @@ interface IShuriken { #### Step 2: Declare dependencies using the `@injectable` & `@inject` decorators Let's continue by declaring some classes (concretions). The classes are implementations of the interfaces that we just declared. All the classes must be annotated with the `@injectable` decorator. -When a class has a dependency on an interface we also need to use the `@inject` decorator to define an identifier for the interface that will be available at runtime. In this case we will use the string literals `"IKatana"` and `"IShuriken"` as runtime identifiers. +When a class has a dependency on an interface we also need to use the `@inject` decorator to define an identifier for the interface that will be available at runtime. In this case we will use the string literals `"Katana"` and `"Shuriken"` as runtime identifiers. > **Note**: InversifyJS also support the usage of Classes and Symbols (continue reading to learn more about this). @@ -132,28 +127,28 @@ import { injectable, inject } from "inversify"; import "reflect-metadata"; @injectable() -class Katana implements IKatana { +class Katana implements Katana { public hit() { return "cut!"; } } @injectable() -class Shuriken implements IShuriken { +class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -176,9 +171,9 @@ import { Katana } from "./entities/katana"; import { Shuriken} from "./entities/shuriken"; var kernel = new Kernel(); -kernel.bind("INinja").to(Ninja); -kernel.bind("IKatana").to(Katana); -kernel.bind("IShuriken").to(Shuriken); +kernel.bind("Ninja").to(Ninja); +kernel.bind("Katana").to(Katana); +kernel.bind("Shuriken").to(Shuriken); export default kernel; ``` @@ -191,13 +186,13 @@ to avoid the [service locator anti-pattern](http://blog.ploeh.dk/2010/02/03/Serv ```ts import kernel = from "./inversify.config"; -var ninja = kernel.get("INinja"); +var ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); // true expect(ninja.sneak()).eql("hit!"); // true ``` -As we can see the `IKatana` and `IShuriken` were successfully resolved and injected into `Ninja`. +As we can see the `Katana` and `Shuriken` were successfully resolved and injected into `Ninja`. InversifyJS supports ES5 and ES6 and can work without TypeScript. Head to the [**JavaScript example**](https://github.com/inversify/InversifyJS/blob/master/wiki/basic_js_example.md) to learn more! diff --git a/gulpfile.js b/gulpfile.js index d8b6c1c1e..008aab0f7 100644 --- a/gulpfile.js +++ b/gulpfile.js @@ -64,7 +64,7 @@ gulp.task("build-bundle-src", function() { // TS compiler options are in tsconfig.json file return bundler.add(mainTsFilePath) - .plugin(tsify) + .plugin(tsify, { typescript: require("typescript") }) .bundle() .pipe(source(outputFileName)) .pipe(buffer()) @@ -98,13 +98,16 @@ gulp.task("build-bundle-compress-src", function() { .pipe(gulp.dest(outputFolder)); }); -var tsLibProject = tsc.createProject("tsconfig.json", { module : "commonjs" }); +var tsLibProject = tsc.createProject("tsconfig.json", { module : "commonjs", typescript: require("typescript") }); gulp.task("build-lib", function() { return gulp.src([ - "src/**/*.ts" + "typings/index.d.ts", + "node_modules/reflect-metadata/reflect-metadata.d.ts", + "src/interfaces/globals.d.ts", + "src/inversify.ts" ]) - .pipe(tsc(tsLibProject )) + .pipe(tsc(tsLibProject)) .on("error", function (err) { process.exit(1); }) @@ -113,11 +116,14 @@ gulp.task("build-lib", function() { .pipe(gulp.dest("lib/")); }); -var tsEsProject = tsc.createProject("tsconfig.json", { module : "es2015" }); +var tsEsProject = tsc.createProject("tsconfig.json", { module : "es2015", typescript: require("typescript") }); gulp.task("build-es", function() { return gulp.src([ - "src/**/*.ts" + "typings/index.d.ts", + "node_modules/reflect-metadata/reflect-metadata.d.ts", + "src/interfaces/globals.d.ts", + "src/inversify.ts" ]) .pipe(tsc(tsEsProject)) .on("error", function (err) { @@ -135,6 +141,9 @@ var tstProject = tsc.createProject("tsconfig.json"); gulp.task("build-src", function() { return gulp.src([ + "typings/index.d.ts", + "node_modules/reflect-metadata/reflect-metadata.d.ts", + "src/interfaces/globals.d.ts", "src/**/*.ts" ]) .pipe(tsc(tstProject)) @@ -148,6 +157,9 @@ var tsTestProject = tsc.createProject("tsconfig.json"); gulp.task("build-test", function() { return gulp.src([ + "typings/index.d.ts", + "node_modules/reflect-metadata/reflect-metadata.d.ts", + "src/interfaces/globals.d.ts", "test/**/*.ts" ]) .pipe(tsc(tsTestProject)) diff --git a/package.json b/package.json index 2a663a984..7df82c424 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "inversify", - "version": "2.0.0-beta.8", + "version": "2.0.0-beta.9", "description": "A lightweight IoC container written in TypeScript.", "main": "lib/inversify.js", "jsnext:main": "es/inversify.js", diff --git a/src/annotation/decorator_utils.ts b/src/annotation/decorator_utils.ts index 633a25508..994e71907 100644 --- a/src/annotation/decorator_utils.ts +++ b/src/annotation/decorator_utils.ts @@ -1,29 +1,24 @@ -/// - +import interfaces from "../interfaces/interfaces"; import * as METADATA_KEY from "../constants/metadata_keys"; import * as ERROR_MSGS from "../constants/error_msgs"; -interface IReflectResult { - [key: string]: IMetadata[]; -} - -function tagParameter(annotationTarget: any, propertyName: string, parameterIndex: number, metadata: IMetadata) { +function tagParameter(annotationTarget: any, propertyName: string, parameterIndex: number, metadata: interfaces.Metadata) { let metadataKey = METADATA_KEY.TAGGED; return _tagParameterOrProperty(metadataKey, annotationTarget, propertyName, metadata, parameterIndex); } -function tagProperty(annotationTarget: any, propertyName: string, metadata: IMetadata) { +function tagProperty(annotationTarget: any, propertyName: string, metadata: interfaces.Metadata) { let metadataKey = METADATA_KEY.TAGGED_PROP; return _tagParameterOrProperty(metadataKey, annotationTarget.constructor, propertyName, metadata); } function _tagParameterOrProperty( - metadataKey: string, annotationTarget: any, propertyName: string, metadata: IMetadata, parameterIndex?: number + metadataKey: string, annotationTarget: any, propertyName: string, metadata: interfaces.Metadata, parameterIndex?: number ) { - let paramsOrPropertiesMetadata: IReflectResult = null; + let paramsOrPropertiesMetadata: interfaces.ReflectResult = {}; let isParameterDecorator = (typeof parameterIndex === "number"); - let key: string = (isParameterDecorator) ? parameterIndex.toString() : propertyName; + let key: string = (parameterIndex !== undefined && isParameterDecorator) ? parameterIndex.toString() : propertyName; // If the decorator is used as a parameter decorator property name must be provided if (isParameterDecorator === true && propertyName !== undefined) { @@ -31,19 +26,17 @@ function _tagParameterOrProperty( } // read metadata if avalible - if (Reflect.hasOwnMetadata(metadataKey, annotationTarget) !== true) { - paramsOrPropertiesMetadata = {}; - } else { + if (Reflect.hasOwnMetadata(metadataKey, annotationTarget) === true) { paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget); } // get metadata for the decorated parameter by its index - let paramOrPropertyMetadata: IMetadata[] = paramsOrPropertiesMetadata[key]; + let paramOrPropertyMetadata: interfaces.Metadata[] = paramsOrPropertiesMetadata[key]; if (Array.isArray(paramOrPropertyMetadata) !== true) { paramOrPropertyMetadata = []; } else { for (let i = 0; i < paramOrPropertyMetadata.length; i++) { - let m: IMetadata = paramOrPropertyMetadata[i]; + let m: interfaces.Metadata = paramOrPropertyMetadata[i]; if (m.key === metadata.key) { throw new Error(`${ERROR_MSGS.DUPLICATED_METADATA} ${m.key}`); } @@ -58,16 +51,16 @@ function _tagParameterOrProperty( } -function _decorate(decorators: ClassDecorator[], target: any): void { +function _decorate(decorators: any[], target: any): void { Reflect.decorate(decorators, target); } -function _param(paramIndex: number, decorator: ParameterDecorator): ClassDecorator { - return function (target: any, key?: string) { decorator(target, key, paramIndex); }; +function _param(paramIndex: number, decorator: ParameterDecorator) { + return function (target: any, key: string) { decorator(target, key, paramIndex); }; } // Allows VanillaJS developers to use decorators: -// decorate(injectable("IFoo", "IBar"), FooBar); +// decorate(injectable("Foo", "Bar"), FooBar); // decorate(targetName("foo", "bar"), FooBar); // decorate(named("foo"), FooBar, 0); // decorate(tagged("bar"), FooBar, 1); diff --git a/src/annotation/inject.ts b/src/annotation/inject.ts index 6dd09ee92..e94ed817d 100644 --- a/src/annotation/inject.ts +++ b/src/annotation/inject.ts @@ -1,5 +1,3 @@ -/// - import Metadata from "../planning/metadata"; import { tagParameter } from "./decorator_utils"; import * as METADATA_KEY from "../constants/metadata_keys"; diff --git a/src/annotation/injectable.ts b/src/annotation/injectable.ts index a6b4e8135..27c2e9876 100644 --- a/src/annotation/injectable.ts +++ b/src/annotation/injectable.ts @@ -1,5 +1,3 @@ -/// - import * as METADATA_KEY from "../constants/metadata_keys"; import * as ERRORS_MSGS from "../constants/error_msgs"; diff --git a/src/annotation/multi_inject.ts b/src/annotation/multi_inject.ts index 63653de48..612791de9 100644 --- a/src/annotation/multi_inject.ts +++ b/src/annotation/multi_inject.ts @@ -1,5 +1,3 @@ -/// - import Metadata from "../planning/metadata"; import { tagParameter } from "./decorator_utils"; import * as METADATA_KEY from "../constants/metadata_keys"; diff --git a/src/annotation/named.ts b/src/annotation/named.ts index 0031500e0..ad5e73d10 100644 --- a/src/annotation/named.ts +++ b/src/annotation/named.ts @@ -1,5 +1,3 @@ -/// - import Metadata from "../planning/metadata"; import { tagParameter, tagProperty } from "./decorator_utils"; import * as METADATA_KEY from "../constants/metadata_keys"; diff --git a/src/annotation/property_injectors.ts b/src/annotation/property_injectors.ts index 4bd2929c9..9428086bb 100644 --- a/src/annotation/property_injectors.ts +++ b/src/annotation/property_injectors.ts @@ -1,4 +1,4 @@ -/// +import interfaces from "../interfaces/interfaces"; const INJECTION = Symbol(); @@ -26,8 +26,8 @@ function _proxyGetter( }); } -function makePropertyInjectDecorator(kernel: IKernel) { - return function(serviceIdentifier: (string|Symbol|INewable)) { +function makePropertyInjectDecorator(kernel: interfaces.Kernel) { + return function(serviceIdentifier: interfaces.ServiceIdentifier) { return function(proto: any, key: string): void { let resolve = () => { @@ -40,8 +40,8 @@ function makePropertyInjectDecorator(kernel: IKernel) { }; } -function makePropertyInjectNamedDecorator(kernel: IKernel) { - return function(serviceIdentifier: (string|Symbol|INewable), named: string) { +function makePropertyInjectNamedDecorator(kernel: interfaces.Kernel) { + return function(serviceIdentifier: interfaces.ServiceIdentifier, named: string) { return function(proto: any, key: string): void { let resolve = () => { @@ -54,8 +54,8 @@ function makePropertyInjectNamedDecorator(kernel: IKernel) { }; } -function makePropertyInjectTaggedDecorator(kernel: IKernel) { - return function(serviceIdentifier: (string|Symbol|INewable), key: string, value: any) { +function makePropertyInjectTaggedDecorator(kernel: interfaces.Kernel) { + return function(serviceIdentifier: interfaces.ServiceIdentifier, key: string, value: any) { return function(proto: any, propertyName: string): void { let resolve = () => { @@ -68,8 +68,8 @@ function makePropertyInjectTaggedDecorator(kernel: IKernel) { }; } -function makePropertyMultiInjectDecorator(kernel: IKernel) { - return function(serviceIdentifier: (string|Symbol|INewable)) { +function makePropertyMultiInjectDecorator(kernel: interfaces.Kernel) { + return function(serviceIdentifier: interfaces.ServiceIdentifier) { return function(proto: any, key: string): void { let resolve = () => { diff --git a/src/annotation/tagged.ts b/src/annotation/tagged.ts index b170eca40..1b32b9f44 100644 --- a/src/annotation/tagged.ts +++ b/src/annotation/tagged.ts @@ -1,5 +1,3 @@ -/// - import Metadata from "../planning/metadata"; import { tagParameter, tagProperty } from "./decorator_utils"; diff --git a/src/annotation/target_name.ts b/src/annotation/target_name.ts index 1cebba1c1..2989f2868 100644 --- a/src/annotation/target_name.ts +++ b/src/annotation/target_name.ts @@ -1,5 +1,3 @@ -/// - import Metadata from "../planning/metadata"; import { tagParameter } from "./decorator_utils"; import * as METADATA_KEY from "../constants/metadata_keys"; diff --git a/src/bindings/binding.ts b/src/bindings/binding.ts index 7f0bc754c..2721515d4 100644 --- a/src/bindings/binding.ts +++ b/src/bindings/binding.ts @@ -1,5 +1,3 @@ -/// - // Binding // ----------- @@ -7,11 +5,12 @@ // (an interface), and an implementation type to be used to satisfy such // a service requirement. +import interfaces from "../interfaces/interfaces"; import BindingScope from "./binding_scope"; import BindingType from "./binding_type"; import guid from "../utils/guid"; -class Binding implements IBinding { +class Binding implements interfaces.Binding { public guid: string; public moduleId: string; @@ -22,10 +21,10 @@ class Binding implements IBinding { public activated: boolean; // A runtime identifier because at runtime we don't have interfaces - public serviceIdentifier: (string|Symbol|INewable); + public serviceIdentifier: interfaces.ServiceIdentifier; // The constructor of a class which must implement T - public implementationType: INewable; + public implementationType: interfaces.Newable; // Cache used to allow singleton scope and BindingType.ConstantValue bindings public cache: T; @@ -40,24 +39,24 @@ class Binding implements IBinding { public type: BindingType; // A factory method used in BindingType.Factory bindings - public factory: IFactoryCreator; + public factory: interfaces.FactoryCreator; // An async factory method used in BindingType.Provider bindings - public provider: IProviderCreator; + public provider: interfaces.ProviderCreator; // A constraint used to limit the contexts in which this binding is applicable - public constraint: (request: IRequest) => boolean; + public constraint: (request: interfaces.Request) => boolean; // On activation handler (invoked just before an instance is added to cache and injected) - public onActivation: (context: IContext, injectable: T) => T; + public onActivation: (context: interfaces.Context, injectable: T) => T; - constructor(serviceIdentifier: (string|Symbol|INewable)) { + constructor(serviceIdentifier: interfaces.ServiceIdentifier) { this.guid = guid(); this.activated = false; this.serviceIdentifier = serviceIdentifier; this.scope = BindingScope.Transient; this.type = BindingType.Invalid; - this.constraint = (request: IRequest) => { return true; }; + this.constraint = (request: interfaces.Request) => { return true; }; this.implementationType = null; this.cache = null; this.factory = null; @@ -65,7 +64,7 @@ class Binding implements IBinding { this.onActivation = null; } - public clone(): IBinding { + public clone(): interfaces.Binding { let clone = new Binding(this.serviceIdentifier); clone.activated = false; clone.implementationType = this.implementationType; diff --git a/src/bindings/binding_count.ts b/src/bindings/binding_count.ts index 9874c94e3..ce966bd89 100644 --- a/src/bindings/binding_count.ts +++ b/src/bindings/binding_count.ts @@ -1,5 +1,3 @@ -/// - enum BindingCount { NoBindingsAvailable = 0, OnlyOneBindingAvailable = 1, diff --git a/src/bindings/binding_scope.ts b/src/bindings/binding_scope.ts index ea1273a19..66266ef5f 100644 --- a/src/bindings/binding_scope.ts +++ b/src/bindings/binding_scope.ts @@ -1,5 +1,3 @@ -/// - enum BindingScope { Transient = 0, Singleton = 1 diff --git a/src/bindings/binding_type.ts b/src/bindings/binding_type.ts index 9beef8556..973355521 100644 --- a/src/bindings/binding_type.ts +++ b/src/bindings/binding_type.ts @@ -1,5 +1,3 @@ -/// - enum BindingType { Invalid = 0, Instance = 1, diff --git a/src/constants/error_msgs.ts b/src/constants/error_msgs.ts index edc6dbb5d..f768ef371 100644 --- a/src/constants/error_msgs.ts +++ b/src/constants/error_msgs.ts @@ -1,5 +1,3 @@ -/// - export const DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times."; export const DUPLICATED_METADATA = "Metadadata key was used more than once in a parameter:"; export const NULL_ARGUMENT = "NULL argument"; @@ -13,8 +11,8 @@ export const CIRCULAR_DEPENDENCY = "Circular dependency found between services:" export const NOT_IMPLEMENTED = "Sorry, this feature is not fully implemented yet."; export const INVALID_BINDING_TYPE = "Invalid binding type:"; export const MISSING_EXPLICIT_CONSTRUCTOR = "Derived class must explicitly declare its constructor:"; -export const INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators " + - "must be applied to the parameters of a class constructor or a class property."; export const NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore."; export const INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Return must be an Array!"; export const INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!"; +export const INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators " + + "must be applied to the parameters of a class constructor or a class property."; diff --git a/src/constants/metadata_keys.ts b/src/constants/metadata_keys.ts index eba5e82f2..af944c4bf 100644 --- a/src/constants/metadata_keys.ts +++ b/src/constants/metadata_keys.ts @@ -1,5 +1,3 @@ -/// - // Used for named bindings export const NAMED_TAG = "named"; diff --git a/src/interfaces/annotations/symbol.d.ts b/src/interfaces/annotations/symbol.d.ts deleted file mode 100644 index 4f7150ac0..000000000 --- a/src/interfaces/annotations/symbol.d.ts +++ /dev/null @@ -1,15 +0,0 @@ -/// - -interface Symbol { - /** Returns a string representation of an object. */ - toString(): string; - - /** Returns the primitive value of the specified object. */ - valueOf(): Object; -} - -interface SymbolConstructor { - (description?: string|number): Symbol; -} - -declare var Symbol: SymbolConstructor; diff --git a/src/interfaces/bindings/binding.d.ts b/src/interfaces/bindings/binding.d.ts deleted file mode 100644 index 47200a76d..000000000 --- a/src/interfaces/bindings/binding.d.ts +++ /dev/null @@ -1,17 +0,0 @@ -/// - -interface IBinding extends IClonable> { - guid: string; - moduleId: string; - activated: boolean; - serviceIdentifier: (string|Symbol|INewable); - implementationType: INewable; - factory: IFactoryCreator; - provider: IProviderCreator; - constraint: (request: IRequest) => boolean; - onActivation: (context: IContext, injectable: T) => T; - cache: T; - dynamicValue: () => T; - scope: number; // BindingScope - type: number; // BindingType -} diff --git a/src/interfaces/bindings/factory.d.ts b/src/interfaces/bindings/factory.d.ts deleted file mode 100644 index 35a8492ff..000000000 --- a/src/interfaces/bindings/factory.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IFactory extends Function { - (...args: any[]): (((...args: any[]) => T)|T); -} diff --git a/src/interfaces/bindings/factory_creator.d.ts b/src/interfaces/bindings/factory_creator.d.ts deleted file mode 100644 index d3f10e064..000000000 --- a/src/interfaces/bindings/factory_creator.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IFactoryCreator extends Function { - (context: IContext): IFactory; -} diff --git a/src/interfaces/bindings/newable.d.ts b/src/interfaces/bindings/newable.d.ts deleted file mode 100644 index 40ab73c67..000000000 --- a/src/interfaces/bindings/newable.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface INewable { - new(...args: any[]): T; -} diff --git a/src/interfaces/bindings/provider.d.ts b/src/interfaces/bindings/provider.d.ts deleted file mode 100644 index bffba00f5..000000000 --- a/src/interfaces/bindings/provider.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IProvider extends Function { - (): Promise; -} diff --git a/src/interfaces/bindings/provider_creator.d.ts b/src/interfaces/bindings/provider_creator.d.ts deleted file mode 100644 index 85a1c5463..000000000 --- a/src/interfaces/bindings/provider_creator.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IProviderCreator extends Function { - (context: IContext): IProvider; -} diff --git a/src/interfaces/globals.d.ts b/src/interfaces/globals.d.ts new file mode 100644 index 000000000..b6fb44134 --- /dev/null +++ b/src/interfaces/globals.d.ts @@ -0,0 +1,46 @@ +interface Map { + size: number; + clear(): void; + delete(key: K): boolean; + forEach(callbackfn: (value: V, index: K, map: Map) => void, thisArg?: any): void; + get(key: K): V; + has(key: K): boolean; + set(key: K, value?: V): Map; +} + +interface MapConstructor { + new (): Map; + new (): Map; + prototype: Map; +} + +interface WeakMap { + clear(): void; + delete(key: K): boolean; + get(key: K): V; + has(key: K): boolean; + set(key: K, value?: V): WeakMap; + +} + +interface WeakMapConstructor { + new (): WeakMap; + new (): WeakMap; + prototype: WeakMap; +} + +interface Symbol { + /** Returns a string representation of an object. */ + toString(): string; + + /** Returns the primitive value of the specified object. */ + valueOf(): Object; +} + +interface SymbolConstructor { + (description?: string|number): Symbol; +} + +declare var Map: MapConstructor; +declare var WeakMap: WeakMapConstructor; +declare var Symbol: SymbolConstructor; diff --git a/src/interfaces/interfaces.d.ts b/src/interfaces/interfaces.d.ts deleted file mode 100644 index ab3aa537e..000000000 --- a/src/interfaces/interfaces.d.ts +++ /dev/null @@ -1,46 +0,0 @@ -/// -/// - -// KERNEL -/// -/// -/// -/// -/// -/// -/// -/// - -// ANNOTATION -/// - -// PLANNING -/// -/// -/// -/// -/// -/// -/// - -// RESOLUTION -/// - -// BINDINGS -/// -/// -/// -/// -/// -/// - -// MIDDLEWARE -/// - -// SYNTAX -/// -/// -/// -/// -/// -/// diff --git a/src/interfaces/interfaces.ts b/src/interfaces/interfaces.ts new file mode 100644 index 000000000..fa9956a08 --- /dev/null +++ b/src/interfaces/interfaces.ts @@ -0,0 +1,216 @@ +namespace interfaces { + + export interface Newable { + new(...args: any[]): T; + } + + export type ServiceIdentifier = (string|Symbol|Newable); + + export interface Binding extends Clonable> { + guid: string; + moduleId: string; + activated: boolean; + serviceIdentifier: ServiceIdentifier; + implementationType: Newable; + factory: FactoryCreator; + provider: ProviderCreator; + constraint: (request: Request) => boolean; + onActivation: (context: Context, injectable: T) => T; + cache: T; + dynamicValue: () => T; + scope: number; // BindingScope + type: number; // BindingType + } + + export interface Factory extends Function { + (...args: any[]): (((...args: any[]) => T)|T); + } + + export interface FactoryCreator extends Function { + (context: Context): Factory; + } + + export interface Provider extends Function { + (): Promise; + } + + export interface ProviderCreator extends Function { + (context: Context): Provider; + } + + export interface PlanAndResolve { + (args: PlanAndResolveArgs): T[]; + } + + export interface PlanAndResolveArgs { + multiInject: boolean; + serviceIdentifier: (string|Symbol|Newable); + target: Target; + contextInterceptor: (contexts: Context) => Context; + } + + export interface Middleware extends Function { + (next: PlanAndResolve): PlanAndResolve; + } + + export interface Context { + guid: string; + kernel: Kernel; + plan: Plan; + addPlan(plan: Plan): void; + } + + export interface ReflectResult { + [key: string]: Metadata[]; + } + + export interface Metadata { + key: string; + value: any; + } + + export interface Plan { + parentContext: Context; + rootRequest: Request; + } + + export interface Planner { + createContext(kernel: Kernel): Context; + createPlan(parentContext: Context, binding: Binding, target: Target): Plan; + getBindings(kernel: Kernel, serviceIdentifier: ServiceIdentifier): Binding[]; + getActiveBindings(parentRequest: Request, target: Target): Binding[]; + } + + export interface QueryableString { + startsWith(searchString: string): boolean; + endsWith(searchString: string): boolean; + contains(searchString: string): boolean; + equals(compareString: string): boolean; + value(): string; + } + + export interface Request { + guid: string; + serviceIdentifier: (string|Symbol|Newable); + parentContext: Context; + parentRequest: Request; + childRequests: Request[]; + target: Target; + bindings: Binding[]; + addChildRequest( + serviceIdentifier: (string|Symbol|Newable), + bindings: (Binding|Binding[]), + target: Target + ): Request; + } + + export interface Target { + guid: string; + serviceIdentifier: (string|Symbol|Newable); + name: QueryableString; + metadata: Array; + hasTag(key: string): boolean; + isArray(): boolean; + matchesArray(name: string|Symbol|any): boolean; + isNamed(): boolean; + isTagged(): boolean; + matchesNamedTag(name: string): boolean; + matchesTag(key: string): (value: any) => boolean; + } + + export interface Resolver { + resolve(context: Context): T; + } + + export interface Kernel { + guid: string; + bind(serviceIdentifier: ServiceIdentifier): BindingToSyntax; + unbind(serviceIdentifier: ServiceIdentifier): void; + unbindAll(): void; + isBound(serviceIdentifier: ServiceIdentifier): boolean; + get(serviceIdentifier: ServiceIdentifier): T; + getNamed(serviceIdentifier: ServiceIdentifier, named: string): T; + getTagged(serviceIdentifier: ServiceIdentifier, key: string, value: any): T; + getAll(serviceIdentifier: ServiceIdentifier): T[]; + load(...modules: KernelModule[]): void; + unload(...modules: KernelModule[]): void; + applyMiddleware(...middleware: Middleware[]): void; + getServiceIdentifierAsString(serviceIdentifier: ServiceIdentifier): string; + snapshot(): void; + restore(): void; + } + + export interface Bind extends Function { + (serviceIdentifier: ServiceIdentifier): BindingToSyntax; + } + + export interface KernelModule { + guid: string; + registry: (bind: Bind) => void; + } + + export interface KernelSnapshot { + bindings: Lookup>; + middleware: PlanAndResolve; + } + + export interface Clonable { + clone(): T; + } + + export interface Lookup extends Clonable> { + add(serviceIdentifier: (string|Symbol|any), value: T): void; + get(serviceIdentifier: (string|Symbol|any)): Array; + remove(serviceIdentifier: (string|Symbol|any)): void; + removeByModuleId(moduleId: string): void; + hasKey(serviceIdentifier: (string|Symbol|any)): boolean; + } + + export interface KeyValuePair { + serviceIdentifier: (string|Symbol|any); + value: Array; + } + + export interface BindingInSyntax { + inSingletonScope(): BindingWhenOnSyntax; + } + + export interface BindingInWhenOnSyntax extends BindingInSyntax, BindingWhenOnSyntax {} + + export interface BindingOnSyntax { + onActivation(fn: (context: Context, injectable: T) => T): BindingWhenSyntax; + } + + export interface BindingToSyntax { + to(constructor: { new(...args: any[]): T; }): BindingInWhenOnSyntax; + toConstantValue(value: T): BindingWhenOnSyntax; + toDynamicValue(func: () => T): BindingWhenOnSyntax; + toConstructor(constructor: Newable): BindingWhenOnSyntax; + toFactory(factory: FactoryCreator): BindingWhenOnSyntax; + toFunction(func: T): BindingWhenOnSyntax; + toAutoFactory(serviceIdentifier: (string|Symbol|Newable)): BindingWhenOnSyntax; + toProvider(provider: ProviderCreator): BindingWhenOnSyntax; + } + + export interface BindingWhenOnSyntax extends BindingWhenSyntax, BindingOnSyntax {} + + export interface BindingWhenSyntax { + when(constraint: (request: Request) => boolean): BindingOnSyntax; + whenTargetNamed(name: string): BindingOnSyntax; + whenTargetTagged(tag: string, value: any): BindingOnSyntax; + whenInjectedInto(parent: (Function|string)): BindingOnSyntax; + whenParentNamed(name: string): BindingOnSyntax; + whenParentTagged(tag: string, value: any): BindingOnSyntax; + whenAnyAncestorIs(ancestor: (Function|string)): BindingOnSyntax; + whenNoAncestorIs(ancestor: (Function|string)): BindingOnSyntax; + whenAnyAncestorNamed(name: string): BindingOnSyntax; + whenAnyAncestorTagged(tag: string, value: any): BindingOnSyntax; + whenNoAncestorNamed(name: string): BindingOnSyntax; + whenNoAncestorTagged(tag: string, value: any): BindingOnSyntax; + whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax; + whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax; + } + +} + +export default interfaces; diff --git a/src/interfaces/kernel/clonable.d.ts b/src/interfaces/kernel/clonable.d.ts deleted file mode 100644 index b4bb81655..000000000 --- a/src/interfaces/kernel/clonable.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -interface IClonable { - clone(): T; -} diff --git a/src/interfaces/kernel/kernel.d.ts b/src/interfaces/kernel/kernel.d.ts deleted file mode 100644 index d46a21431..000000000 --- a/src/interfaces/kernel/kernel.d.ts +++ /dev/null @@ -1,19 +0,0 @@ -/// - -interface IKernel { - guid: string; - bind(serviceIdentifier: (string|Symbol|INewable)): IBindingToSyntax; - unbind(serviceIdentifier: (string|Symbol|INewable)): void; - unbindAll(): void; - isBound(serviceIdentifier: (string|Symbol|INewable)): boolean; - get(serviceIdentifier: (string|Symbol|INewable)): T; - getNamed(serviceIdentifier: (string|Symbol|INewable), named: string): T; - getTagged(serviceIdentifier: (string|Symbol|INewable), key: string, value: any): T; - getAll(serviceIdentifier: (string|Symbol|INewable)): T[]; - load(...modules: IKernelModule[]): void; - unload(...modules: IKernelModule[]): void; - applyMiddleware(...middleware: IMiddleware[]): void; - getServiceIdentifierAsString(serviceIdentifier: (string|Symbol|INewable)): string; - snapshot(): void; - restore(): void; -} diff --git a/src/interfaces/kernel/kernel_module.d.ts b/src/interfaces/kernel/kernel_module.d.ts deleted file mode 100644 index eb3304600..000000000 --- a/src/interfaces/kernel/kernel_module.d.ts +++ /dev/null @@ -1,10 +0,0 @@ -/// - -interface IBind extends Function { - (serviceIdentifier: (string|Symbol|INewable)): IBindingToSyntax; -} - -interface IKernelModule { - guid: string; - registry: (bind: IBind) => void; -} diff --git a/src/interfaces/kernel/kernel_snapshot.d.ts b/src/interfaces/kernel/kernel_snapshot.d.ts deleted file mode 100644 index 00b7e2d15..000000000 --- a/src/interfaces/kernel/kernel_snapshot.d.ts +++ /dev/null @@ -1,4 +0,0 @@ -interface IKernelSnapshot { - bindings: ILookup>; - middleware: PlanAndResolve; -} diff --git a/src/interfaces/kernel/key_value_pair.d.ts b/src/interfaces/kernel/key_value_pair.d.ts deleted file mode 100644 index 5388b2352..000000000 --- a/src/interfaces/kernel/key_value_pair.d.ts +++ /dev/null @@ -1,4 +0,0 @@ -interface IKeyValuePair { - serviceIdentifier: (string|Symbol|any); - value: Array; -} diff --git a/src/interfaces/kernel/lookup.d.ts b/src/interfaces/kernel/lookup.d.ts deleted file mode 100644 index fce4beef8..000000000 --- a/src/interfaces/kernel/lookup.d.ts +++ /dev/null @@ -1,7 +0,0 @@ -interface ILookup extends IClonable> { - add(serviceIdentifier: (string|Symbol|any), value: T): void; - get(serviceIdentifier: (string|Symbol|any)): Array; - remove(serviceIdentifier: (string|Symbol|any)): void; - removeByModuleId(moduleId: string): void; - hasKey(serviceIdentifier: (string|Symbol|any)): boolean; -} diff --git a/src/interfaces/kernel/map.d.ts b/src/interfaces/kernel/map.d.ts deleted file mode 100644 index dd6caf9b4..000000000 --- a/src/interfaces/kernel/map.d.ts +++ /dev/null @@ -1,17 +0,0 @@ -interface Map { - size: number; - clear(): void; - delete(key: K): boolean; - forEach(callbackfn: (value: V, index: K, map: Map) => void, thisArg?: any): void; - get(key: K): V; - has(key: K): boolean; - set(key: K, value?: V): Map; -} - -interface MapConstructor { - new (): Map; - new (): Map; - prototype: Map; -} - -declare var Map: MapConstructor; diff --git a/src/interfaces/kernel/weakmap.d.ts b/src/interfaces/kernel/weakmap.d.ts deleted file mode 100644 index 3de35353f..000000000 --- a/src/interfaces/kernel/weakmap.d.ts +++ /dev/null @@ -1,16 +0,0 @@ -interface WeakMap { - clear(): void; - delete(key: K): boolean; - get(key: K): V; - has(key: K): boolean; - set(key: K, value?: V): WeakMap; - -} - -interface WeakMapConstructor { - new (): WeakMap; - new (): WeakMap; - prototype: WeakMap; -} - -declare var WeakMap: WeakMapConstructor; diff --git a/src/interfaces/middleware/middleware.d.ts b/src/interfaces/middleware/middleware.d.ts deleted file mode 100644 index 33e46faff..000000000 --- a/src/interfaces/middleware/middleware.d.ts +++ /dev/null @@ -1,14 +0,0 @@ -interface PlanAndResolve { - (args: PlanAndResolveArgs): T[]; -} - -interface IMiddleware extends Function { - (next: PlanAndResolve): PlanAndResolve; -} - -interface PlanAndResolveArgs { - multiInject: boolean; - serviceIdentifier: (string|Symbol|INewable); - target: ITarget; - contextInterceptor: (contexts: IContext) => IContext; -} diff --git a/src/interfaces/planning/context.d.ts b/src/interfaces/planning/context.d.ts deleted file mode 100644 index 5bd333de9..000000000 --- a/src/interfaces/planning/context.d.ts +++ /dev/null @@ -1,12 +0,0 @@ -interface IContext { - - guid: string; - - /// Gets the kernel that is driving the resolution. - kernel: IKernel; - - /// Gets or sets the resolution plan. - plan: IPlan; - - addPlan(plan: IPlan): void; -} diff --git a/src/interfaces/planning/metadata.d.ts b/src/interfaces/planning/metadata.d.ts deleted file mode 100644 index cd85d5526..000000000 --- a/src/interfaces/planning/metadata.d.ts +++ /dev/null @@ -1,4 +0,0 @@ -interface IMetadata { - key: string; - value: any; -} diff --git a/src/interfaces/planning/plan.d.ts b/src/interfaces/planning/plan.d.ts deleted file mode 100644 index 2fea5c341..000000000 --- a/src/interfaces/planning/plan.d.ts +++ /dev/null @@ -1,7 +0,0 @@ -/// -/// - -interface IPlan { - parentContext: IContext; - rootRequest: IRequest; -} diff --git a/src/interfaces/planning/planner.d.ts b/src/interfaces/planning/planner.d.ts deleted file mode 100644 index 165ca860b..000000000 --- a/src/interfaces/planning/planner.d.ts +++ /dev/null @@ -1,10 +0,0 @@ -/// -/// -///áá - -interface IPlanner { - createContext(kernel: IKernel): IContext; - createPlan(parentContext: IContext, binding: IBinding, target: ITarget): IPlan; - getBindings(kernel: IKernel, serviceIdentifier: (string|Symbol|INewable)): IBinding[]; - getActiveBindings(parentRequest: IRequest, target: ITarget): IBinding[]; -} diff --git a/src/interfaces/planning/queryable_string.d.ts b/src/interfaces/planning/queryable_string.d.ts deleted file mode 100644 index ff3a031f6..000000000 --- a/src/interfaces/planning/queryable_string.d.ts +++ /dev/null @@ -1,7 +0,0 @@ -interface IQueryableString { - startsWith(searchString: string): boolean; - endsWith(searchString: string): boolean; - contains(searchString: string): boolean; - equals(compareString: string): boolean; - value(): string; -} diff --git a/src/interfaces/planning/request.d.ts b/src/interfaces/planning/request.d.ts deleted file mode 100644 index 31c425c3d..000000000 --- a/src/interfaces/planning/request.d.ts +++ /dev/null @@ -1,29 +0,0 @@ -interface IRequest { - - // An unique ID - guid: string; - - // The service that was requested. - serviceIdentifier: (string|Symbol|INewable); - - // The parent context. - parentContext: IContext; - - // The parent request. - parentRequest: IRequest; - - // The child requests - childRequests: IRequest[]; - - // Gets the target that will receive the injection, if any. - target: ITarget; - - // Gets the stack of bindings which have been activated by this request. - bindings: IBinding[]; - - // Adds a child request to the request - addChildRequest( - serviceIdentifier: (string|Symbol|INewable), - bindings: (IBinding|IBinding[]), - target: ITarget): IRequest; -} diff --git a/src/interfaces/planning/target.d.ts b/src/interfaces/planning/target.d.ts deleted file mode 100644 index 1c39f730c..000000000 --- a/src/interfaces/planning/target.d.ts +++ /dev/null @@ -1,16 +0,0 @@ -/// -/// - -interface ITarget { - guid: string; - serviceIdentifier: (string|Symbol|INewable); - name: IQueryableString; - metadata: Array; - hasTag(key: string): boolean; - isArray(): boolean; - matchesArray(name: string|Symbol|any): boolean; - isNamed(): boolean; - isTagged(): boolean; - matchesNamedTag(name: string): boolean; - matchesTag(key: string): (value: any) => boolean; -} diff --git a/src/interfaces/resolution/resolver.d.ts b/src/interfaces/resolution/resolver.d.ts deleted file mode 100644 index d43c4ee9d..000000000 --- a/src/interfaces/resolution/resolver.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IResolver { - resolve(context: IContext): Service; -} diff --git a/src/interfaces/syntax/binding_in_syntax.d.ts b/src/interfaces/syntax/binding_in_syntax.d.ts deleted file mode 100644 index ffd5a1f88..000000000 --- a/src/interfaces/syntax/binding_in_syntax.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IBindingInSyntax { - inSingletonScope(): IBindingWhenOnSyntax; -} diff --git a/src/interfaces/syntax/binding_in_when_on_syntax.d.ts b/src/interfaces/syntax/binding_in_when_on_syntax.d.ts deleted file mode 100644 index aeae61320..000000000 --- a/src/interfaces/syntax/binding_in_when_on_syntax.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -/// - -interface IBindingInWhenOnSyntax extends IBindingInSyntax, IBindingWhenOnSyntax {} diff --git a/src/interfaces/syntax/binding_on_syntax.d.ts b/src/interfaces/syntax/binding_on_syntax.d.ts deleted file mode 100644 index 74ea6d205..000000000 --- a/src/interfaces/syntax/binding_on_syntax.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -/// - -interface IBindingOnSyntax { - onActivation(fn: (context: IContext, injectable: T) => T): IBindingWhenSyntax; -} diff --git a/src/interfaces/syntax/binding_to_syntax.d.ts b/src/interfaces/syntax/binding_to_syntax.d.ts deleted file mode 100644 index ea4ff427c..000000000 --- a/src/interfaces/syntax/binding_to_syntax.d.ts +++ /dev/null @@ -1,12 +0,0 @@ -/// - -interface IBindingToSyntax { - to(constructor: { new(...args: any[]): T; }): IBindingInWhenOnSyntax; - toConstantValue(value: T): IBindingWhenOnSyntax; - toDynamicValue(func: () => T): IBindingWhenOnSyntax; - toConstructor(constructor: INewable): IBindingWhenOnSyntax; - toFactory(factory: IFactoryCreator): IBindingWhenOnSyntax; - toFunction(func: T): IBindingWhenOnSyntax; - toAutoFactory(serviceIdentifier: (string|Symbol|INewable)): IBindingWhenOnSyntax; - toProvider(provider: IProviderCreator): IBindingWhenOnSyntax; -} diff --git a/src/interfaces/syntax/binding_when_on_syntax.d.ts b/src/interfaces/syntax/binding_when_on_syntax.d.ts deleted file mode 100644 index 67943712b..000000000 --- a/src/interfaces/syntax/binding_when_on_syntax.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -/// - -interface IBindingWhenOnSyntax extends IBindingWhenSyntax, IBindingOnSyntax {} diff --git a/src/interfaces/syntax/binding_when_syntax.d.ts b/src/interfaces/syntax/binding_when_syntax.d.ts deleted file mode 100644 index 9008c9447..000000000 --- a/src/interfaces/syntax/binding_when_syntax.d.ts +++ /dev/null @@ -1,18 +0,0 @@ -/// - -interface IBindingWhenSyntax { - when(constraint: (request: IRequest) => boolean): IBindingOnSyntax; - whenTargetNamed(name: string): IBindingOnSyntax; - whenTargetTagged(tag: string, value: any): IBindingOnSyntax; - whenInjectedInto(parent: (Function|string)): IBindingOnSyntax; - whenParentNamed(name: string): IBindingOnSyntax; - whenParentTagged(tag: string, value: any): IBindingOnSyntax; - whenAnyAncestorIs(ancestor: (Function|string)): IBindingOnSyntax; - whenNoAncestorIs(ancestor: (Function|string)): IBindingOnSyntax; - whenAnyAncestorNamed(name: string): IBindingOnSyntax; - whenAnyAncestorTagged(tag: string, value: any): IBindingOnSyntax; - whenNoAncestorNamed(name: string): IBindingOnSyntax; - whenNoAncestorTagged(tag: string, value: any): IBindingOnSyntax; - whenAnyAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax; - whenNoAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax; -} diff --git a/src/inversify.ts b/src/inversify.ts index 050ae30e8..89cb66a66 100644 --- a/src/inversify.ts +++ b/src/inversify.ts @@ -1,5 +1,3 @@ -/// - // Inversify // --------- diff --git a/src/kernel/kernel.ts b/src/kernel/kernel.ts index 5a40f7607..49b9deac4 100644 --- a/src/kernel/kernel.ts +++ b/src/kernel/kernel.ts @@ -1,5 +1,3 @@ -/// - // Kernel // ------ @@ -15,6 +13,7 @@ // to be told which implementation type (classes) to associate // with each service type (interfaces). +import interfaces from "../interfaces/interfaces"; import BindingCount from "../bindings/binding_count"; import Binding from "../bindings/binding"; import Lookup from "./lookup"; @@ -29,13 +28,13 @@ import Request from "../planning/request"; import KernelSnapshot from "./kernel_snapshot"; import guid from "../utils/guid"; -class Kernel implements IKernel { +class Kernel implements interfaces.Kernel { public guid: string; - private _planner: IPlanner; - private _resolver: IResolver; - private _middleware: PlanAndResolve; - private _bindingDictionary: ILookup>; + private _planner: Planner; + private _resolver: Resolver; + private _middleware: interfaces.PlanAndResolve; + private _bindingDictionary: interfaces.Lookup>; private _snapshots: Array; // Initialize private properties @@ -43,14 +42,14 @@ class Kernel implements IKernel { this.guid = guid(); this._planner = new Planner(); this._resolver = new Resolver(); - this._bindingDictionary = new Lookup>(); + this._bindingDictionary = new Lookup>(); this._middleware = null; this._snapshots = []; } - public load(...modules: IKernelModule[]): void { + public load(...modules: interfaces.KernelModule[]): void { let getBindFunction = (moduleId: string) => { - return (serviceIdentifier: (string|Symbol|INewable)) => { + return (serviceIdentifier: interfaces.ServiceIdentifier) => { let _bind = this.bind.bind(this); let bindingToSyntax = _bind(serviceIdentifier); (bindingToSyntax)._binding.moduleId = moduleId; @@ -63,21 +62,21 @@ class Kernel implements IKernel { }); } - public unload(...modules: IKernelModule[]): void { + public unload(...modules: interfaces.KernelModule[]): void { modules.forEach((module) => { this._bindingDictionary.removeByModuleId(module.guid); }); } // Regiters a type binding - public bind(serviceIdentifier: (string|Symbol|INewable)): IBindingToSyntax { + public bind(serviceIdentifier: interfaces.ServiceIdentifier): interfaces.BindingToSyntax { let binding = new Binding(serviceIdentifier); this._bindingDictionary.add(serviceIdentifier, binding); return new BindingToSyntax(binding); } // Removes a type binding from the registry by its key - public unbind(serviceIdentifier: (string|Symbol|INewable)): void { + public unbind(serviceIdentifier: interfaces.ServiceIdentifier): void { try { this._bindingDictionary.remove(serviceIdentifier); } catch (e) { @@ -87,11 +86,11 @@ class Kernel implements IKernel { // Removes all the type bindings from the registry public unbindAll(): void { - this._bindingDictionary = new Lookup>(); + this._bindingDictionary = new Lookup>(); } // Allows to check if there are bindings available for serviceIdentifier - public isBound(serviceIdentifier: (string|Symbol|INewable)): boolean { + public isBound(serviceIdentifier: interfaces.ServiceIdentifier): boolean { let bindings = this._planner.getBindings(this, serviceIdentifier); return bindings.length > 0; } @@ -99,24 +98,24 @@ class Kernel implements IKernel { // Resolves a dependency by its runtime identifier // The runtime identifier must be associated with only one binding // use getAll when the runtime identifier is associated with multiple bindings - public get(serviceIdentifier: (string|Symbol|INewable)): T { + public get(serviceIdentifier: interfaces.ServiceIdentifier): T { return this._get({ - contextInterceptor: (context: IContext) => { return context; }, + contextInterceptor: (context: interfaces.Context) => { return context; }, multiInject: false, serviceIdentifier: serviceIdentifier, target: null })[0]; } - public getNamed(serviceIdentifier: (string|Symbol|INewable), named: string): T { + public getNamed(serviceIdentifier: interfaces.ServiceIdentifier, named: string): T { return this.getTagged(serviceIdentifier, METADATA_KEY.NAMED_TAG, named); } - public getTagged(serviceIdentifier: (string|Symbol|INewable), key: string, value: any): T { + public getTagged(serviceIdentifier: interfaces.ServiceIdentifier, key: string, value: any): T { let metadata = new Metadata(key, value); let target = new Target(null, serviceIdentifier, metadata); return this._get({ - contextInterceptor: (context: IContext) => { return context; }, + contextInterceptor: (context: interfaces.Context) => { return context; }, multiInject: false, serviceIdentifier: serviceIdentifier, target: target @@ -136,7 +135,7 @@ class Kernel implements IKernel { this._middleware = snapshot.middleware; } - public getServiceIdentifierAsString(serviceIdentifier: (string|Symbol|INewable)): string { + public getServiceIdentifierAsString(serviceIdentifier: interfaces.ServiceIdentifier): string { let type = typeof serviceIdentifier; if (type === "function") { let _serviceIdentifier: any = serviceIdentifier; @@ -149,8 +148,8 @@ class Kernel implements IKernel { } } - public applyMiddleware(...middlewares: IMiddleware[]): void { - let previous: PlanAndResolve = (this._middleware) ? this._middleware : this._planAndResolve.bind(this); + public applyMiddleware(...middlewares: interfaces.Middleware[]): void { + let previous: interfaces.PlanAndResolve = (this._middleware) ? this._middleware : this._planAndResolve.bind(this); this._middleware = middlewares.reduce((prev, curr) => { return curr(prev); }, previous); @@ -158,16 +157,16 @@ class Kernel implements IKernel { // Resolves a dependency by its runtime identifier // The runtime identifier can be associated with one or multiple bindings - public getAll(serviceIdentifier: (string|Symbol|INewable)): T[] { + public getAll(serviceIdentifier: interfaces.ServiceIdentifier): T[] { return this._get({ - contextInterceptor: (context: IContext) => { return context; }, + contextInterceptor: (context: interfaces.Context) => { return context; }, multiInject: true, serviceIdentifier: serviceIdentifier, target: null }); } - private _get(args: PlanAndResolveArgs): T[] { + private _get(args: interfaces.PlanAndResolveArgs): T[] { let result: T[] = null; if (this._middleware) { result = this._middleware(args); @@ -180,13 +179,17 @@ class Kernel implements IKernel { return result; } - private _planAndResolve(args: PlanAndResolveArgs): T[] { + private _planAndResolve(args: interfaces.PlanAndResolveArgs): T[] { let contexts = this._plan(args.multiInject, args.serviceIdentifier, args.target); let results = this._resolve(contexts, args.contextInterceptor); return results; } - private _getActiveBindings(multiInject: boolean, serviceIdentifier: (string|Symbol|INewable), target: ITarget): IBinding[] { + private _getActiveBindings( + multiInject: boolean, + serviceIdentifier: interfaces.ServiceIdentifier, + target: interfaces.Target + ): interfaces.Binding[] { let bindings = this._planner.getBindings(this, serviceIdentifier); @@ -225,7 +228,11 @@ class Kernel implements IKernel { } - private _plan(multiInject: boolean, serviceIdentifier: (string|Symbol|INewable), target: ITarget): IContext[] { + private _plan( + multiInject: boolean, + serviceIdentifier: interfaces.ServiceIdentifier, + target: interfaces.Target + ): interfaces.Context[] { let bindings = this._getActiveBindings(multiInject, serviceIdentifier, target); @@ -236,13 +243,17 @@ class Kernel implements IKernel { return contexts; } - private _createContext(binding: IBinding, target: ITarget): IContext { + private _createContext(binding: interfaces.Binding, target: interfaces.Target): interfaces.Context { let context = this._planner.createContext(this); this._planner.createPlan(context, binding, target); return context; } - private _resolve(contexts: IContext[], contextInterceptor: (context: IContext) => IContext): T[] { + private _resolve( + contexts: interfaces.Context[], + contextInterceptor: (context: interfaces.Context) => interfaces.Context + ): T[] { + let results = contexts.map((context) => { return this._resolver.resolve(contextInterceptor(context)); }); diff --git a/src/kernel/kernel_module.ts b/src/kernel/kernel_module.ts index 07f9d63ea..41ab3b0bc 100644 --- a/src/kernel/kernel_module.ts +++ b/src/kernel/kernel_module.ts @@ -1,13 +1,12 @@ -/// - +import interfaces from "../interfaces/interfaces"; import guid from "../utils/guid"; -class KernelModule implements IKernelModule { +class KernelModule implements interfaces.KernelModule { public guid: string; - public registry: (bind: IBind) => void; + public registry: (bind: interfaces.Bind) => void; - public constructor(registry: (bind: IBind) => void) { + public constructor(registry: (bind: interfaces.Bind) => void) { this.guid = guid(); this.registry = registry; } diff --git a/src/kernel/kernel_snapshot.ts b/src/kernel/kernel_snapshot.ts index b75fd2a54..9e891d81b 100644 --- a/src/kernel/kernel_snapshot.ts +++ b/src/kernel/kernel_snapshot.ts @@ -1,13 +1,17 @@ -/// +import interfaces from "../interfaces/interfaces"; -export default class KernelSnapshot implements IKernelSnapshot { - public bindings: ILookup>; - public middleware: PlanAndResolve; +class KernelSnapshot implements interfaces.KernelSnapshot { - public static of(bindings: ILookup>, middleware: PlanAndResolve) { + public bindings: interfaces.Lookup>; + public middleware: interfaces.PlanAndResolve; + + public static of(bindings: interfaces.Lookup>, middleware: interfaces.PlanAndResolve) { let snapshot = new KernelSnapshot(); snapshot.bindings = bindings; snapshot.middleware = middleware; return snapshot; } + } + +export default KernelSnapshot; diff --git a/src/kernel/key_value_pair.ts b/src/kernel/key_value_pair.ts index abb8d4ecd..909f71a41 100644 --- a/src/kernel/key_value_pair.ts +++ b/src/kernel/key_value_pair.ts @@ -1,6 +1,6 @@ -/// +import interfaces from "../interfaces/interfaces"; -class KeyValuePair implements IKeyValuePair { +class KeyValuePair implements interfaces.KeyValuePair { public serviceIdentifier: (string|Symbol|any); public value: Array; diff --git a/src/kernel/lookup.ts b/src/kernel/lookup.ts index aa044e676..c2562c9c8 100644 --- a/src/kernel/lookup.ts +++ b/src/kernel/lookup.ts @@ -1,17 +1,11 @@ -/// - -// TypeBinding -// ----------- - -// A dictionary with support for duplicate keys - +import interfaces from "../interfaces/interfaces"; import KeyValuePair from "./key_value_pair"; import * as ERROR_MSGS from "../constants/error_msgs"; -class Lookup> implements ILookup { +class Lookup> implements interfaces.Lookup { // dictionary used store multiple values for each key - private _dictionary: Array>; + private _dictionary: Array>; public constructor() { this._dictionary = []; @@ -59,12 +53,12 @@ class Lookup> implements ILookup { } public removeByModuleId(moduleId: string): void { - this._dictionary.forEach((keyValuePair: IKeyValuePair) => { + this._dictionary.forEach((keyValuePair: KeyValuePair) => { keyValuePair.value = keyValuePair.value.filter((binding: any) => { return binding.moduleId !== moduleId; }); }); - this._dictionary = this._dictionary.filter((keyValuePair: IKeyValuePair) => { + this._dictionary = this._dictionary.filter((keyValuePair: KeyValuePair) => { return keyValuePair.value.length > 0; }); } @@ -84,7 +78,8 @@ class Lookup> implements ILookup { // returns a new Lookup instance; note: this is not a deep clone, only Lookup related data structure (dictionary) is // cloned, content remains the same - public clone(): ILookup { + public clone(): interfaces.Lookup { + let l = new Lookup(); for (let entry of this._dictionary) { diff --git a/src/planning/context.ts b/src/planning/context.ts index 30a102bf0..608374704 100644 --- a/src/planning/context.ts +++ b/src/planning/context.ts @@ -1,19 +1,18 @@ -/// - +import interfaces from "../interfaces/interfaces"; import guid from "../utils/guid"; -class Context implements IContext { +class Context implements interfaces.Context { public guid: string; - public kernel: IKernel; - public plan: IPlan; + public kernel: interfaces.Kernel; + public plan: interfaces.Plan; - public constructor(kernel: IKernel) { + public constructor(kernel: interfaces.Kernel) { this.guid = guid(); this.kernel = kernel; } - public addPlan(plan: IPlan) { + public addPlan(plan: interfaces.Plan) { this.plan = plan; } } diff --git a/src/planning/metadata.ts b/src/planning/metadata.ts index 241c1bd78..0f6bad26e 100644 --- a/src/planning/metadata.ts +++ b/src/planning/metadata.ts @@ -1,6 +1,6 @@ -/// +import interfaces from "../interfaces/interfaces"; -class Metadata implements IMetadata { +class Metadata implements interfaces.Metadata { public key: string; public value: any; diff --git a/src/planning/plan.ts b/src/planning/plan.ts index dbb8afe94..8f56384b5 100644 --- a/src/planning/plan.ts +++ b/src/planning/plan.ts @@ -1,11 +1,11 @@ -/// +import interfaces from "../interfaces/interfaces"; -class Plan implements IPlan { +class Plan implements interfaces.Plan { - public parentContext: IContext; - public rootRequest: IRequest; + public parentContext: interfaces.Context; + public rootRequest: interfaces.Request; - public constructor(parentContext: IContext, rootRequest: IRequest) { + public constructor(parentContext: interfaces.Context, rootRequest: interfaces.Request) { this.parentContext = parentContext; this.rootRequest = rootRequest; } diff --git a/src/planning/planner.ts b/src/planning/planner.ts index 2bce5903d..e44dd55ea 100644 --- a/src/planning/planner.ts +++ b/src/planning/planner.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../interfaces/interfaces"; import Plan from "./plan"; import Context from "./context"; import Request from "./request"; @@ -8,13 +7,17 @@ import * as METADATA_KEY from "../constants/metadata_keys"; import * as ERROR_MSGS from "../constants/error_msgs"; import BindingType from "../bindings/binding_type"; -class Planner implements IPlanner { +class Planner implements interfaces.Planner { - public createContext(kernel: IKernel): IContext { + public createContext(kernel: interfaces.Kernel): interfaces.Context { return new Context(kernel); } - public createPlan(context: IContext, binding: IBinding, target: ITarget): IPlan { + public createPlan( + context: interfaces.Context, + binding: interfaces.Binding, + target: interfaces.Target + ): interfaces.Plan { let rootRequest = new Request( binding.serviceIdentifier, @@ -33,8 +36,12 @@ class Planner implements IPlanner { return plan; } - public getBindings(kernel: IKernel, serviceIdentifier: (string|Symbol|INewable)): IBinding[] { - let bindings: IBinding[] = []; + public getBindings( + kernel: interfaces.Kernel, + serviceIdentifier: interfaces.ServiceIdentifier + ): interfaces.Binding[] { + + let bindings: interfaces.Binding[] = []; let _kernel: any = kernel; let _bindingDictionary = _kernel._bindingDictionary; if (_bindingDictionary.hasKey(serviceIdentifier)) { @@ -43,10 +50,13 @@ class Planner implements IPlanner { return bindings; } - public getActiveBindings(parentRequest: IRequest, target: ITarget): IBinding[] { + public getActiveBindings( + parentRequest: interfaces.Request, + target: interfaces.Target + ): interfaces.Binding[] { let bindings = this.getBindings(parentRequest.parentContext.kernel, target.serviceIdentifier); - let activeBindings: IBinding[] = []; + let activeBindings: interfaces.Binding[] = []; if (bindings.length > 1 && target.isArray() === false) { @@ -72,7 +82,7 @@ class Planner implements IPlanner { return activeBindings; } - private _createSubRequest(parentRequest: IRequest, target: ITarget) { + private _createSubRequest(parentRequest: interfaces.Request, target: interfaces.Target) { try { let activeBindings = this.getActiveBindings(parentRequest, target); @@ -106,7 +116,11 @@ class Planner implements IPlanner { } } - private _createChildRequest(parentRequest: IRequest, target: ITarget, bindings: IBinding[]) { + private _createChildRequest( + parentRequest: interfaces.Request, + target: interfaces.Target, + bindings: interfaces.Binding[] + ) { // Use the only active binding to create a child request let childRequest = parentRequest.addChildRequest(target.serviceIdentifier, bindings, target); @@ -132,7 +146,8 @@ class Planner implements IPlanner { } private _throwWhenCircularDependenciesFound( - request: IRequest, previousServiceIdentifiers: (string|Symbol|INewable)[] = [] + request: interfaces.Request, + previousServiceIdentifiers: interfaces.ServiceIdentifier[] = [] ) { previousServiceIdentifiers.push(request.serviceIdentifier); @@ -154,7 +169,7 @@ class Planner implements IPlanner { }); } - private _getDependencies(func: Function): ITarget[] { + private _getDependencies(func: Function): interfaces.Target[] { if (func === null) { return []; } let constructorName = (func).name; @@ -171,7 +186,7 @@ class Planner implements IPlanner { // User generated annotations let targetsMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED, func) || []; - let targets: ITarget[] = []; + let targets: interfaces.Target[] = []; for (let i = 0; i < func.length; i++) { @@ -180,7 +195,7 @@ class Planner implements IPlanner { // Create map from array of metadata for faster access to metadata let targetMetadata = targetsMetadata[i.toString()] || []; let targetMetadataMap: any = {}; - targetMetadata.forEach((m: IMetadata) => { + targetMetadata.forEach((m: interfaces.Metadata) => { targetMetadataMap[m.key.toString()] = m.value; }); diff --git a/src/planning/queryable_string.ts b/src/planning/queryable_string.ts index 199953320..b56d20034 100644 --- a/src/planning/queryable_string.ts +++ b/src/planning/queryable_string.ts @@ -1,6 +1,6 @@ -/// +import interfaces from "../interfaces/interfaces"; -class QueryableString implements IQueryableString { +class QueryableString implements interfaces.QueryableString { private str: string; diff --git a/src/planning/request.ts b/src/planning/request.ts index c963911b8..17ac18b72 100644 --- a/src/planning/request.ts +++ b/src/planning/request.ts @@ -1,23 +1,24 @@ -/// +import interfaces from "../interfaces/interfaces"; import guid from "../utils/guid"; -class Request implements IRequest { +class Request implements interfaces.Request { public guid: string; - public serviceIdentifier: (string|Symbol|INewable); - public parentContext: IContext; - public parentRequest: IRequest; - public bindings: IBinding[]; - public childRequests: IRequest[]; - public target: ITarget; + public serviceIdentifier: interfaces.ServiceIdentifier; + public parentContext: interfaces.Context; + public parentRequest: interfaces.Request; + public bindings: interfaces.Binding[]; + public childRequests: interfaces.Request[]; + public target: interfaces.Target; public constructor( - serviceIdentifier: (string|Symbol|INewable), - parentContext: IContext, - parentRequest: IRequest, - bindings: (IBinding|IBinding[]), - target: ITarget = null) { + serviceIdentifier: interfaces.ServiceIdentifier, + parentContext: interfaces.Context, + parentRequest: interfaces.Request, + bindings: (interfaces.Binding|interfaces.Binding[]), + target: interfaces.Target = null + ) { this.guid = guid(); this.serviceIdentifier = serviceIdentifier; @@ -30,8 +31,9 @@ class Request implements IRequest { public addChildRequest( serviceIdentifier: string, - bindings: (IBinding|IBinding[]), - target: ITarget): IRequest { + bindings: (interfaces.Binding|interfaces.Binding[]), + target: interfaces.Target + ): interfaces.Request { let child = new Request( serviceIdentifier, diff --git a/src/planning/target.ts b/src/planning/target.ts index f5584b9ed..8dea8f41a 100644 --- a/src/planning/target.ts +++ b/src/planning/target.ts @@ -1,25 +1,28 @@ -/// - +import interfaces from "../interfaces/interfaces"; import Metadata from "../planning/metadata"; import QueryableString from "./queryable_string"; import * as METADATA_KEY from "../constants/metadata_keys"; import guid from "../utils/guid"; -class Target implements ITarget { +class Target implements interfaces.Target { public guid: string; - public serviceIdentifier: (string|Symbol|INewable); - public name: QueryableString; - public metadata: Array; + public serviceIdentifier: interfaces.ServiceIdentifier; + public name: interfaces.QueryableString; + public metadata: Array; - constructor(name: string, serviceIdentifier: (string|Symbol|INewable), namedOrTagged?: (string|IMetadata)) { + constructor( + name: string, + serviceIdentifier: interfaces.ServiceIdentifier, + namedOrTagged?: (string|Metadata) + ) { this.guid = guid(); this.serviceIdentifier = serviceIdentifier; this.name = new QueryableString(name || ""); - this.metadata = new Array(); - let metadataItem: IMetadata = null; + this.metadata = new Array(); + let metadataItem: interfaces.Metadata = null; // is named target if (typeof namedOrTagged === "string") { diff --git a/src/resolution/resolver.ts b/src/resolution/resolver.ts index 8df076b4e..29c095fe8 100644 --- a/src/resolution/resolver.ts +++ b/src/resolution/resolver.ts @@ -1,17 +1,16 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingScope from "../bindings/binding_scope"; import BindingType from "../bindings/binding_type"; import * as ERROR_MSGS from "../constants/error_msgs"; -class Resolver implements IResolver { +class Resolver implements interfaces.Resolver { - public resolve(context: IContext): Service { + public resolve(context: interfaces.Context): T { let rootRequest = context.plan.rootRequest; return this._resolve(rootRequest); } - private _resolve(request: IRequest): any { + private _resolve(request: interfaces.Request): any { let bindings = request.bindings; let childRequests = request.childRequests; @@ -22,7 +21,7 @@ class Resolver implements IResolver { ) { // Create an array instead of creating an instance - return childRequests.map((childRequest) => { return this._resolve(childRequest); }); + return childRequests.map((childRequest: interfaces.Request) => { return this._resolve(childRequest); }); } else { @@ -65,7 +64,7 @@ class Resolver implements IResolver { let constr = binding.implementationType; if (childRequests.length > 0) { - let injections = childRequests.map((childRequest) => { + let injections = childRequests.map((childRequest: interfaces.Request) => { return this._resolve(childRequest); }); @@ -79,7 +78,7 @@ class Resolver implements IResolver { case BindingType.Invalid: default: // The user probably created a binding but didn't finish it - // e.g. kernel.bind("ISomething"); missing BindingToSyntax + // e.g. kernel.bind("Something"); missing BindingToSyntax let serviceIdentifier = request.parentContext.kernel.getServiceIdentifierAsString(request.serviceIdentifier); throw new Error(`${ERROR_MSGS.INVALID_BINDING_TYPE} ${serviceIdentifier}`); } diff --git a/src/syntax/binding_in_syntax.ts b/src/syntax/binding_in_syntax.ts index d1609d108..04d79bced 100644 --- a/src/syntax/binding_in_syntax.ts +++ b/src/syntax/binding_in_syntax.ts @@ -1,17 +1,16 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingScope from "../bindings/binding_scope"; import BindingWhenOnSyntax from "./binding_when_on_syntax"; -class BindingInSyntax implements IBindingInSyntax { +class BindingInSyntax implements interfaces.BindingInSyntax { - private _binding: IBinding; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; } - public inSingletonScope(): IBindingWhenOnSyntax { + public inSingletonScope(): interfaces.BindingWhenOnSyntax { this._binding.scope = BindingScope.Singleton; return new BindingWhenOnSyntax(this._binding); } diff --git a/src/syntax/binding_in_when_on_syntax.ts b/src/syntax/binding_in_when_on_syntax.ts index a8cca3a96..a03926922 100644 --- a/src/syntax/binding_in_when_on_syntax.ts +++ b/src/syntax/binding_in_when_on_syntax.ts @@ -1,84 +1,83 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingInSyntax from "./binding_in_syntax"; import BindingWhenSyntax from "./binding_when_syntax"; import BindingOnSyntax from "./binding_on_syntax"; -class BindingInWhenOnSyntax implements IBindingInSyntax, IBindingWhenSyntax, IBindingOnSyntax { +class BindingInWhenOnSyntax implements interfaces.BindingInSyntax, interfaces.BindingWhenSyntax, interfaces.BindingOnSyntax { - private _bindingInSyntax: BindingInSyntax; - private _bindingWhenSyntax: IBindingWhenSyntax; - private _bindingOnSyntax: IBindingOnSyntax; - private _binding: IBinding; + private _bindingInSyntax: interfaces.BindingInSyntax; + private _bindingWhenSyntax: interfaces.BindingWhenSyntax; + private _bindingOnSyntax: interfaces.BindingOnSyntax; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; this._bindingWhenSyntax = new BindingWhenSyntax(this._binding); this._bindingOnSyntax = new BindingOnSyntax(this._binding); this._bindingInSyntax = new BindingInSyntax(binding); } - public inSingletonScope(): IBindingWhenOnSyntax { + public inSingletonScope(): interfaces.BindingWhenOnSyntax { return this._bindingInSyntax.inSingletonScope(); } - public when(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.when(constraint); } - public whenTargetNamed(name: string): IBindingOnSyntax { + public whenTargetNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenTargetNamed(name); } - public whenTargetTagged(tag: string, value: any): IBindingOnSyntax { + public whenTargetTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenTargetTagged(tag, value); } - public whenInjectedInto(parent: (Function|string)): IBindingOnSyntax { + public whenInjectedInto(parent: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenInjectedInto(parent); } - public whenParentNamed(name: string): IBindingOnSyntax { + public whenParentNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenParentNamed(name); } - public whenParentTagged(tag: string, value: any): IBindingOnSyntax { + public whenParentTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenParentTagged(tag, value); } - public whenAnyAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { + public whenAnyAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor); } - public whenNoAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { + public whenNoAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorIs(ancestor); } - public whenAnyAncestorNamed(name: string): IBindingOnSyntax { + public whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorNamed(name); } - public whenAnyAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenAnyAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value); } - public whenNoAncestorNamed(name: string): IBindingOnSyntax { + public whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorNamed(name); } - public whenNoAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenNoAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value); } - public whenAnyAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint); } - public whenNoAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorMatches(constraint); } - public onActivation(handler: (context: IContext, injectable: T) => T): IBindingWhenSyntax { + public onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax { return this._bindingOnSyntax.onActivation(handler); } diff --git a/src/syntax/binding_on_syntax.ts b/src/syntax/binding_on_syntax.ts index 170faee5c..4ba510aa8 100644 --- a/src/syntax/binding_on_syntax.ts +++ b/src/syntax/binding_on_syntax.ts @@ -1,16 +1,15 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingWhenSyntax from "./binding_when_syntax"; -class BindingOnSyntax implements IBindingOnSyntax { +class BindingOnSyntax implements interfaces.BindingOnSyntax { - private _binding: IBinding; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; } - public onActivation(handler: (context: IContext, injectable: T) => T): IBindingWhenSyntax { + public onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax { this._binding.onActivation = handler; return new BindingWhenSyntax(this._binding); } diff --git a/src/syntax/binding_to_syntax.ts b/src/syntax/binding_to_syntax.ts index 2f6d42e5e..c36acc4a6 100644 --- a/src/syntax/binding_to_syntax.ts +++ b/src/syntax/binding_to_syntax.ts @@ -1,25 +1,24 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingInWhenOnSyntax from "./binding_in_when_on_syntax"; import BindingWhenOnSyntax from "./binding_when_on_syntax"; import BindingType from "../bindings/binding_type"; import * as ERROR_MSGS from "../constants/error_msgs"; -class BindingToSyntax implements IBindingToSyntax { +class BindingToSyntax implements interfaces.BindingToSyntax { - private _binding: IBinding; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; } - public to(constructor: { new(...args: any[]): T; }): IBindingInWhenOnSyntax { + public to(constructor: { new(...args: any[]): T; }): interfaces.BindingInWhenOnSyntax { this._binding.type = BindingType.Instance; this._binding.implementationType = constructor; return new BindingInWhenOnSyntax(this._binding); } - public toConstantValue(value: T): IBindingWhenOnSyntax { + public toConstantValue(value: T): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.ConstantValue; this._binding.cache = value; this._binding.dynamicValue = null; @@ -27,7 +26,7 @@ class BindingToSyntax implements IBindingToSyntax { return new BindingWhenOnSyntax(this._binding); } - public toDynamicValue(func: () => T): IBindingWhenOnSyntax { + public toDynamicValue(func: () => T): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.DynamicValue; this._binding.cache = null; this._binding.dynamicValue = func; @@ -35,19 +34,19 @@ class BindingToSyntax implements IBindingToSyntax { return new BindingWhenOnSyntax(this._binding); } - public toConstructor(constructor: INewable): IBindingWhenOnSyntax { + public toConstructor(constructor: interfaces.Newable): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.Constructor; this._binding.implementationType = constructor; return new BindingWhenOnSyntax(this._binding); } - public toFactory(factory: IFactoryCreator): IBindingWhenOnSyntax { + public toFactory(factory: interfaces.FactoryCreator): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.Factory; this._binding.factory = factory; return new BindingWhenOnSyntax(this._binding); } - public toFunction(func: T): IBindingWhenOnSyntax { + public toFunction(func: T): interfaces.BindingWhenOnSyntax { // toFunction is an alias of toConstantValue if (typeof func !== "function") { throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING); }; let bindingWhenOnSyntax = this.toConstantValue(func); @@ -55,7 +54,7 @@ class BindingToSyntax implements IBindingToSyntax { return bindingWhenOnSyntax; } - public toAutoFactory(serviceIdentifier: (string|Symbol|INewable)): IBindingWhenOnSyntax { + public toAutoFactory(serviceIdentifier: interfaces.ServiceIdentifier): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.Factory; this._binding.factory = (context) => { return () => { @@ -65,7 +64,7 @@ class BindingToSyntax implements IBindingToSyntax { return new BindingWhenOnSyntax(this._binding); } - public toProvider(provider: IProviderCreator): IBindingWhenOnSyntax { + public toProvider(provider: interfaces.ProviderCreator): interfaces.BindingWhenOnSyntax { this._binding.type = BindingType.Provider; this._binding.provider = provider; return new BindingWhenOnSyntax(this._binding); diff --git a/src/syntax/binding_when_on_syntax.ts b/src/syntax/binding_when_on_syntax.ts index 8f3baf6f6..f6d552a3c 100644 --- a/src/syntax/binding_when_on_syntax.ts +++ b/src/syntax/binding_when_on_syntax.ts @@ -1,77 +1,76 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingWhenSyntax from "./binding_when_syntax"; import BindingOnSyntax from "./binding_on_syntax"; -class BindingWhenOnSyntax implements IBindingWhenSyntax, IBindingOnSyntax { +class BindingWhenOnSyntax implements interfaces.BindingWhenSyntax, interfaces.BindingOnSyntax { - private _bindingWhenSyntax: IBindingWhenSyntax; - private _bindingOnSyntax: IBindingOnSyntax; - private _binding: IBinding; + private _bindingWhenSyntax: interfaces.BindingWhenSyntax; + private _bindingOnSyntax: interfaces.BindingOnSyntax; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; this._bindingWhenSyntax = new BindingWhenSyntax(this._binding); this._bindingOnSyntax = new BindingOnSyntax(this._binding); } - public when(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.when(constraint); } - public whenTargetNamed(name: string): IBindingOnSyntax { + public whenTargetNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenTargetNamed(name); } - public whenTargetTagged(tag: string, value: any): IBindingOnSyntax { + public whenTargetTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenTargetTagged(tag, value); } - public whenInjectedInto(parent: (Function|string)): IBindingOnSyntax { + public whenInjectedInto(parent: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenInjectedInto(parent); } - public whenParentNamed(name: string): IBindingOnSyntax { + public whenParentNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenParentNamed(name); } - public whenParentTagged(tag: string, value: any): IBindingOnSyntax { + public whenParentTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenParentTagged(tag, value); } - public whenAnyAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { + public whenAnyAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor); } - public whenNoAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { + public whenNoAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorIs(ancestor); } - public whenAnyAncestorNamed(name: string): IBindingOnSyntax { + public whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorNamed(name); } - public whenAnyAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenAnyAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value); } - public whenNoAncestorNamed(name: string): IBindingOnSyntax { + public whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorNamed(name); } - public whenNoAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenNoAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value); } - public whenAnyAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint); } - public whenNoAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { return this._bindingWhenSyntax.whenNoAncestorMatches(constraint); } - public onActivation(handler: (context: IContext, injectable: T) => T): IBindingWhenSyntax { + public onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax { return this._bindingOnSyntax.onActivation(handler); } diff --git a/src/syntax/binding_when_syntax.ts b/src/syntax/binding_when_syntax.ts index 7e288e4f0..6a82fd4ee 100644 --- a/src/syntax/binding_when_syntax.ts +++ b/src/syntax/binding_when_syntax.ts @@ -1,114 +1,113 @@ -/// - +import interfaces from "../interfaces/interfaces"; import BindingOnSyntax from "./binding_on_syntax"; import { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint } from "./constraint_helpers"; -class BindingWhenSyntax implements IBindingWhenSyntax { +class BindingWhenSyntax implements interfaces.BindingWhenSyntax { - private _binding: IBinding; + private _binding: interfaces.Binding; - public constructor(binding: IBinding) { + public constructor(binding: interfaces.Binding) { this._binding = binding; } - public when(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { this._binding.constraint = constraint; return new BindingOnSyntax(this._binding); } - public whenTargetNamed(name: string): IBindingOnSyntax { + public whenTargetNamed(name: string): interfaces.BindingOnSyntax { this._binding.constraint = namedConstraint(name); return new BindingOnSyntax(this._binding); } - public whenTargetTagged(tag: string, value: any): IBindingOnSyntax { + public whenTargetTagged(tag: string, value: any): interfaces.BindingOnSyntax { this._binding.constraint = taggedConstraint(tag)(value); return new BindingOnSyntax(this._binding); } - public whenInjectedInto(parent: (Function|string)): IBindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + public whenInjectedInto(parent: (Function|string)): interfaces.BindingOnSyntax { + this._binding.constraint = (request: interfaces.Request) => { return typeConstraint(parent)(request.parentRequest); }; return new BindingOnSyntax(this._binding); } - public whenParentNamed(name: string): IBindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + public whenParentNamed(name: string): interfaces.BindingOnSyntax { + this._binding.constraint = (request: interfaces.Request) => { return namedConstraint(name)(request.parentRequest); }; return new BindingOnSyntax(this._binding); } - public whenParentTagged(tag: string, value: any): IBindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + public whenParentTagged(tag: string, value: any): interfaces.BindingOnSyntax { + this._binding.constraint = (request: interfaces.Request) => { return taggedConstraint(tag)(value)(request.parentRequest); }; return new BindingOnSyntax(this._binding); } - public whenAnyAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + public whenAnyAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { + this._binding.constraint = (request: interfaces.Request) => { return traverseAncerstors(request, typeConstraint(ancestor)); }; return new BindingOnSyntax(this._binding); } - public whenNoAncestorIs(ancestor: (Function|string)): IBindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + public whenNoAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax { + this._binding.constraint = (request: interfaces.Request) => { return !traverseAncerstors(request, typeConstraint(ancestor)); }; return new BindingOnSyntax(this._binding); } - public whenAnyAncestorNamed(name: string): IBindingOnSyntax { + public whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return traverseAncerstors(request, namedConstraint(name)); }; return new BindingOnSyntax(this._binding); } - public whenNoAncestorNamed(name: string): IBindingOnSyntax { + public whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return !traverseAncerstors(request, namedConstraint(name)); }; return new BindingOnSyntax(this._binding); } - public whenAnyAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenAnyAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return traverseAncerstors(request, taggedConstraint(tag)(value)); }; return new BindingOnSyntax(this._binding); } - public whenNoAncestorTagged(tag: string, value: any): IBindingOnSyntax { + public whenNoAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return !traverseAncerstors(request, taggedConstraint(tag)(value)); }; return new BindingOnSyntax(this._binding); } - public whenAnyAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return traverseAncerstors(request, constraint); }; return new BindingOnSyntax(this._binding); } - public whenNoAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax { + public whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax { - this._binding.constraint = (request: IRequest) => { + this._binding.constraint = (request: interfaces.Request) => { return !traverseAncerstors(request, constraint); }; diff --git a/src/syntax/constraint_helpers.ts b/src/syntax/constraint_helpers.ts index f09091110..0bee9726b 100644 --- a/src/syntax/constraint_helpers.ts +++ b/src/syntax/constraint_helpers.ts @@ -1,8 +1,11 @@ -/// - +import interfaces from "../interfaces/interfaces"; import * as METADATA_KEY from "../constants/metadata_keys"; -let traverseAncerstors = (request: IRequest, constraint: (request: IRequest) => boolean): boolean => { +let traverseAncerstors = ( + request: interfaces.Request, + constraint: (request: interfaces.Request) => boolean +): boolean => { + let parent = request.parentRequest; if (parent !== null) { return constraint(parent) ? true : traverseAncerstors(parent, constraint); @@ -13,13 +16,13 @@ let traverseAncerstors = (request: IRequest, constraint: (request: IRequest) => // This helpers use currying to help you to generate constraints -let taggedConstraint = (key: string) => (value: any) => (request: IRequest) => { +let taggedConstraint = (key: string) => (value: any) => (request: interfaces.Request) => { return request.target.matchesTag(key)(value); }; let namedConstraint = taggedConstraint(METADATA_KEY.NAMED_TAG); -let typeConstraint = (type: (Function|string)) => (request: IRequest) => { +let typeConstraint = (type: (Function|string)) => (request: interfaces.Request) => { // Using index 0 because constraints are applied // to one binding at a time (see Planner class) diff --git a/test/annotation/inject.test.ts b/test/annotation/inject.test.ts index 3782025a1..56f3c8a24 100644 --- a/test/annotation/inject.test.ts +++ b/test/annotation/inject.test.ts @@ -1,27 +1,26 @@ declare function __decorate(decorators: ClassDecorator[], target: any, key?: any, desc?: any): void; declare function __param(paramIndex: number, decorator: ParameterDecorator): ClassDecorator; -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import { decorate } from "../../src/annotation/decorator_utils"; import inject from "../../src/annotation/inject"; import * as METADATA_KEY from "../../src/constants/metadata_keys"; import * as ERROR_MSGS from "../../src/constants/error_msgs"; -interface IKatana {} -interface IShuriken {} -class Katana implements IKatana {} -class Shuriken implements IShuriken {} +interface Katana {} +interface Shuriken {} +class Katana implements Katana {} +class Shuriken implements Shuriken {} class WarriorWithoutDecorator { - private _primaryWeapon: IKatana; - private _secondaryWeapon: IShuriken; + private _primaryWeapon: Katana; + private _secondaryWeapon: Shuriken; constructor( - primary: IKatana, - secondary: IShuriken + primary: Katana, + secondary: Shuriken ) { this._primaryWeapon = primary; @@ -31,12 +30,12 @@ class WarriorWithoutDecorator { class DecoratedWarrior { - private _primaryWeapon: IKatana; - private _secondaryWeapon: IShuriken; + private _primaryWeapon: Katana; + private _secondaryWeapon: Shuriken; constructor( - @inject("IKatana") primary: IKatana, - @inject("IShuriken") secondary: IShuriken + @inject("Katana") primary: Katana, + @inject("Shuriken") secondary: Shuriken ) { this._primaryWeapon = primary; @@ -46,12 +45,12 @@ class DecoratedWarrior { class InvalidDecoratorUsageWarrior { - private _primaryWeapon: IKatana; - private _secondaryWeapon: IShuriken; + private _primaryWeapon: Katana; + private _secondaryWeapon: Shuriken; constructor( - primary: IKatana, - secondary: IShuriken + primary: Katana, + secondary: Shuriken ) { this._primaryWeapon = primary; @@ -70,16 +69,16 @@ describe("@inject", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.INJECT_TAG); - expect(m1.value).to.be.eql("IKatana"); + expect(m1.value).to.be.eql("Katana"); expect(paramsMetadata["0"][1]).to.be.undefined; // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql(METADATA_KEY.INJECT_TAG); - expect(m2.value).to.be.eql("IShuriken"); + expect(m2.value).to.be.eql("Shuriken"); expect(paramsMetadata["1"][1]).to.be.undefined; // no more metadata should be available @@ -90,7 +89,7 @@ describe("@inject", () => { it("Should throw when applayed mutiple times", () => { let useDecoratorMoreThanOnce = function() { - __decorate([ __param(0, inject("IKatana")), __param(0, inject("IShurien")) ], InvalidDecoratorUsageWarrior); + __decorate([ __param(0, inject("Katana")), __param(0, inject("Shurien")) ], InvalidDecoratorUsageWarrior); }; let msg = `${ERROR_MSGS.DUPLICATED_METADATA} ${METADATA_KEY.INJECT_TAG}`; @@ -101,7 +100,7 @@ describe("@inject", () => { it("Should throw when not applayed to a constructor", () => { let useDecoratorOnMethodThatIsNotAContructor = function() { - __decorate([ __param(0, inject("IKatana")) ], + __decorate([ __param(0, inject("Katana")) ], InvalidDecoratorUsageWarrior.prototype, "test", Object.getOwnPropertyDescriptor(InvalidDecoratorUsageWarrior.prototype, "test")); }; @@ -113,18 +112,18 @@ describe("@inject", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShurien {} + interface Katana {} + interface Shurien {} let VanillaJSWarrior = (function () { - function Warrior(primary: IKatana, secondary: IShurien) { + function Warrior(primary: Katana, secondary: Shurien) { // ... } return Warrior; })(); - decorate(inject("IKatana"), VanillaJSWarrior, 0); - decorate(inject("IShurien"), VanillaJSWarrior, 1); + decorate(inject("Katana"), VanillaJSWarrior, 0); + decorate(inject("Shurien"), VanillaJSWarrior, 1); let metadataKey = METADATA_KEY.TAGGED; let paramsMetadata = Reflect.getMetadata(metadataKey, VanillaJSWarrior); @@ -132,16 +131,16 @@ describe("@inject", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.INJECT_TAG); - expect(m1.value).to.be.eql("IKatana"); + expect(m1.value).to.be.eql("Katana"); expect(paramsMetadata["0"][1]).to.be.undefined; // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql(METADATA_KEY.INJECT_TAG); - expect(m2.value).to.be.eql("IShurien"); + expect(m2.value).to.be.eql("Shurien"); expect(paramsMetadata["1"][1]).to.be.undefined; // no more metadata should be available diff --git a/test/annotation/injectable.test.ts b/test/annotation/injectable.test.ts index 711e695fb..7e65770ca 100644 --- a/test/annotation/injectable.test.ts +++ b/test/annotation/injectable.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import { injectable, decorate } from "../../src/inversify"; import * as METADATA_KEY from "../../src/constants/metadata_keys"; @@ -11,15 +9,15 @@ describe("@injectable", () => { class Katana {} - interface IWeapon {} + interface Weapon {} @injectable() class Warrior { private _primaryWeapon: Katana; - private _secondaryWeapon: IWeapon; + private _secondaryWeapon: Weapon; - public constructor(primaryWeapon: Katana, secondaryWeapon: IWeapon) { + public constructor(primaryWeapon: Katana, secondaryWeapon: Weapon) { this._primaryWeapon = primaryWeapon; this._secondaryWeapon = secondaryWeapon; } @@ -49,11 +47,11 @@ describe("@injectable", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShuriken {} + interface Katana {} + interface Shuriken {} let VanillaJSWarrior = (function () { - function VanillaJSWarrior(primary: IKatana, secondary: IShuriken) { + function VanillaJSWarrior(primary: Katana, secondary: Shuriken) { // ... } return VanillaJSWarrior; diff --git a/test/annotation/multi_inject.test.ts b/test/annotation/multi_inject.test.ts index d98a9c515..a21f1d6b6 100644 --- a/test/annotation/multi_inject.test.ts +++ b/test/annotation/multi_inject.test.ts @@ -1,25 +1,24 @@ declare function __decorate(decorators: ClassDecorator[], target: any, key?: any, desc?: any): void; declare function __param(paramIndex: number, decorator: ParameterDecorator): ClassDecorator; -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import { decorate } from "../../src/annotation/decorator_utils"; import multiInject from "../../src/annotation/multi_inject"; import * as METADATA_KEY from "../../src/constants/metadata_keys"; import * as ERROR_MSGS from "../../src/constants/error_msgs"; -interface IWeapon {} -class Katana implements IWeapon {} -class Shuriken implements IWeapon {} +interface Weapon {} +class Katana implements Weapon {} +class Shuriken implements Weapon {} class WarriorWithoutDecorator { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - weapons: IWeapon[] + weapons: Weapon[] ) { this._primaryWeapon = weapons[0]; @@ -29,11 +28,11 @@ class WarriorWithoutDecorator { class DecoratedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @multiInject("IWeapon") weapons: IWeapon[] + @multiInject("Weapon") weapons: Weapon[] ) { this._primaryWeapon = weapons[0]; @@ -43,11 +42,11 @@ class DecoratedWarrior { class InvalidDecoratorUsageWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - weapons: IWeapon[] + weapons: Weapon[] ) { this._primaryWeapon = weapons[0]; this._secondaryWeapon = weapons[1]; @@ -65,9 +64,9 @@ describe("@multiInject", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.MULTI_INJECT_TAG); - expect(m1.value).to.be.eql("IWeapon"); + expect(m1.value).to.be.eql("Weapon"); expect(paramsMetadata["0"][1]).to.be.undefined; // no more metadata should be available @@ -78,7 +77,7 @@ describe("@multiInject", () => { it("Should throw when applayed mutiple times", () => { let useDecoratorMoreThanOnce = function() { - __decorate([ __param(0, multiInject("IWeapon")), __param(0, multiInject("IWeapon")) ], InvalidDecoratorUsageWarrior); + __decorate([ __param(0, multiInject("Weapon")), __param(0, multiInject("Weapon")) ], InvalidDecoratorUsageWarrior); }; let msg = `${ERROR_MSGS.DUPLICATED_METADATA} ${METADATA_KEY.MULTI_INJECT_TAG}`; @@ -89,7 +88,7 @@ describe("@multiInject", () => { it("Should throw when not applayed to a constructor", () => { let useDecoratorOnMethodThatIsNotAContructor = function() { - __decorate([ __param(0, multiInject("IWeapon")) ], + __decorate([ __param(0, multiInject("Weapon")) ], InvalidDecoratorUsageWarrior.prototype, "test", Object.getOwnPropertyDescriptor(InvalidDecoratorUsageWarrior.prototype, "test")); }; @@ -101,17 +100,17 @@ describe("@multiInject", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShurien {} + interface Katana {} + interface Shurien {} let VanillaJSWarrior = (function () { - function Warrior(primary: IKatana, secondary: IShurien) { + function Warrior(primary: Katana, secondary: Shurien) { // ... } return Warrior; })(); - decorate(multiInject("IWeapon"), VanillaJSWarrior, 0); + decorate(multiInject("Weapon"), VanillaJSWarrior, 0); let metadataKey = METADATA_KEY.TAGGED; let paramsMetadata = Reflect.getMetadata(metadataKey, VanillaJSWarrior); @@ -119,9 +118,9 @@ describe("@multiInject", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.MULTI_INJECT_TAG); - expect(m1.value).to.be.eql("IWeapon"); + expect(m1.value).to.be.eql("Weapon"); expect(paramsMetadata["0"][1]).to.be.undefined; // no more metadata should be available diff --git a/test/annotation/named.test.ts b/test/annotation/named.test.ts index 73d5307b2..ae5f19a68 100644 --- a/test/annotation/named.test.ts +++ b/test/annotation/named.test.ts @@ -1,26 +1,25 @@ declare function __decorate(decorators: ClassDecorator[], target: any, key?: any, desc?: any): void; declare function __param(paramIndex: number, decorator: ParameterDecorator): ClassDecorator; -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import { decorate } from "../../src/annotation/decorator_utils"; import named from "../../src/annotation/named"; import * as METADATA_KEY from "../../src/constants/metadata_keys"; import * as ERROR_MSGS from "../../src/constants/error_msgs"; -interface IWeapon {} -class Katana implements IWeapon {} -class Shuriken implements IWeapon {} +interface Weapon {} +class Katana implements Weapon {} +class Shuriken implements Weapon {} class NamedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @named("more_powerful") primary: IWeapon, - @named("less_powerful") secondary: IWeapon) { + @named("more_powerful") primary: Weapon, + @named("less_powerful") secondary: Weapon) { this._primaryWeapon = primary; this._secondaryWeapon = secondary; @@ -28,12 +27,12 @@ class NamedWarrior { } class InvalidDecoratorUsageWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - primary: IWeapon, - secondary: IWeapon + primary: Weapon, + secondary: Weapon ) { this._primaryWeapon = primary; @@ -53,14 +52,14 @@ describe("@named", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.NAMED_TAG); expect(m1.value).to.be.eql("more_powerful"); expect(paramsMetadata["0"][1]).to.be.undefined; // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql(METADATA_KEY.NAMED_TAG); expect(m2.value).to.be.eql("less_powerful"); expect(paramsMetadata["1"][1]).to.be.undefined; @@ -74,7 +73,7 @@ describe("@named", () => { class Warrior { @named("throwwable") - public weapon: IWeapon; + public weapon: Weapon; } let metadataKey = METADATA_KEY.TAGGED_PROP; @@ -113,11 +112,11 @@ describe("@named", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShurien {} + interface Katana {} + interface Shurien {} let VanillaJSWarrior = (function () { - function NamedVanillaJSWarrior(primary: IKatana, secondary: IShurien) { + function NamedVanillaJSWarrior(primary: Katana, secondary: Shurien) { // ... } return NamedVanillaJSWarrior; @@ -132,14 +131,14 @@ describe("@named", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql(METADATA_KEY.NAMED_TAG); expect(m1.value).to.be.eql("more_powerful"); expect(paramsMetadata["0"][1]).to.be.undefined; // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql(METADATA_KEY.NAMED_TAG); expect(m2.value).to.be.eql("less_powerful"); expect(paramsMetadata["1"][1]).to.be.undefined; diff --git a/test/annotation/property_injectors.test.ts b/test/annotation/property_injectors.test.ts index d3b2f05da..ef9c635bb 100644 --- a/test/annotation/property_injectors.test.ts +++ b/test/annotation/property_injectors.test.ts @@ -1,30 +1,26 @@ -/// - import { expect } from "chai"; - +import Kernel from "../../src/kernel/kernel"; +import injectable from "../../src/annotation/injectable"; +import named from "../../src/annotation/named"; +import tagged from "../../src/annotation/tagged"; import { makePropertyInjectNamedDecorator, makePropertyInjectDecorator, makePropertyInjectTaggedDecorator } from "../../src/annotation/property_injectors"; -import Kernel from "../../src/kernel/kernel"; -import injectable from "../../src/annotation/injectable"; -import named from "../../src/annotation/named"; -import tagged from "../../src/annotation/tagged"; - describe("makePropertyInjectDecorator and makePropertyMultiInjectDecorator", () => { - let TYPES = { IWeapon: "IWeapon" }; + let TYPES = { Weapon: "Weapon" }; - interface IWeapon { + interface Weapon { name: string; durability: number; use(): void; } @injectable() - class Sword implements IWeapon { + class Sword implements Weapon { public name: string; public durability: number; public constructor() { @@ -37,7 +33,7 @@ describe("makePropertyInjectDecorator and makePropertyMultiInjectDecorator", () } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name: string; public durability: number; public constructor() { @@ -56,18 +52,18 @@ describe("makePropertyInjectDecorator and makePropertyMultiInjectDecorator", () class Warrior { - @injectNamed(TYPES.IWeapon, "not-throwwable") + @injectNamed(TYPES.Weapon, "not-throwwable") @named("not-throwwable") - public primaryWeapon: IWeapon; + public primaryWeapon: Weapon; - @injectNamed(TYPES.IWeapon, "throwwable") + @injectNamed(TYPES.Weapon, "throwwable") @named("throwwable") - public secondaryWeapon: IWeapon; + public secondaryWeapon: Weapon; } - kernel.bind(TYPES.IWeapon).to(Sword).whenTargetNamed("not-throwwable"); - kernel.bind(TYPES.IWeapon).to(Shuriken).whenTargetNamed("throwwable"); + kernel.bind(TYPES.Weapon).to(Sword).whenTargetNamed("not-throwwable"); + kernel.bind(TYPES.Weapon).to(Shuriken).whenTargetNamed("throwwable"); let warrior1 = new Warrior(); @@ -83,18 +79,18 @@ describe("makePropertyInjectDecorator and makePropertyMultiInjectDecorator", () class Warrior { - @injectTagged(TYPES.IWeapon, "throwwable", false) + @injectTagged(TYPES.Weapon, "throwwable", false) @tagged("throwwable", false) - public primaryWeapon: IWeapon; + public primaryWeapon: Weapon; - @injectTagged(TYPES.IWeapon, "throwwable", true) + @injectTagged(TYPES.Weapon, "throwwable", true) @tagged("throwwable", true) - public secondaryWeapon: IWeapon; + public secondaryWeapon: Weapon; } - kernel.bind(TYPES.IWeapon).to(Sword).whenTargetTagged("throwwable", false); - kernel.bind(TYPES.IWeapon).to(Shuriken).whenTargetTagged("throwwable", true); + kernel.bind(TYPES.Weapon).to(Sword).whenTargetTagged("throwwable", false); + kernel.bind(TYPES.Weapon).to(Shuriken).whenTargetTagged("throwwable", true); let warrior1 = new Warrior(); expect(warrior1.primaryWeapon).to.be.instanceof(Sword); @@ -108,11 +104,11 @@ describe("makePropertyInjectDecorator and makePropertyMultiInjectDecorator", () let inject = makePropertyInjectDecorator(kernel); class Warrior { - @inject(TYPES.IWeapon) - public weapon: IWeapon; + @inject(TYPES.Weapon) + public weapon: Weapon; } - kernel.bind(TYPES.IWeapon).to(Sword); + kernel.bind(TYPES.Weapon).to(Sword); let warrior1 = new Warrior(); expect(warrior1.weapon).to.be.instanceof(Sword); diff --git a/test/annotation/tagged.test.ts b/test/annotation/tagged.test.ts index a51761086..67edca3a5 100644 --- a/test/annotation/tagged.test.ts +++ b/test/annotation/tagged.test.ts @@ -1,26 +1,25 @@ declare function __decorate(decorators: ClassDecorator[], target: any, key?: any, desc?: any): void; declare function __param(paramIndex: number, decorator: ParameterDecorator): ClassDecorator; -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import { decorate } from "../../src/annotation/decorator_utils"; import tagged from "../../src/annotation/tagged"; import * as METADATA_KEY from "../../src/constants/metadata_keys"; import * as ERRORS_MSGS from "../../src/constants/error_msgs"; -interface IWeapon {} -class Katana implements IWeapon {} -class Shuriken implements IWeapon {} +interface Weapon {} +class Katana implements Weapon {} +class Shuriken implements Weapon {} class UnTaggedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - primary: IWeapon, - secondary: IWeapon) { + primary: Weapon, + secondary: Weapon) { this._primaryWeapon = primary; this._secondaryWeapon = secondary; @@ -29,12 +28,12 @@ class UnTaggedWarrior { class TaggedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @tagged("power", 1) primary: IWeapon, - @tagged("power", 2) secondary: IWeapon) { + @tagged("power", 1) primary: Weapon, + @tagged("power", 2) secondary: Weapon) { this._primaryWeapon = primary; this._secondaryWeapon = secondary; @@ -43,12 +42,12 @@ class TaggedWarrior { class DoubleTaggedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @tagged("power", 1) @tagged("distance", 1) primary: IWeapon, - @tagged("power", 2) @tagged("distance", 5) secondary: IWeapon) { + @tagged("power", 1) @tagged("distance", 1) primary: Weapon, + @tagged("power", 2) @tagged("distance", 5) secondary: Weapon) { this._primaryWeapon = primary; this._secondaryWeapon = secondary; @@ -57,12 +56,12 @@ class DoubleTaggedWarrior { class InvalidDecoratorUsageWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - primary: IWeapon, - secondary: IWeapon) { + primary: Weapon, + secondary: Weapon) { this._primaryWeapon = primary; this._secondaryWeapon = secondary; @@ -81,7 +80,7 @@ describe("@Tagged", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql("power"); expect(m1.value).to.be.eql(1); @@ -90,7 +89,7 @@ describe("@Tagged", () => { // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql("power"); expect(m2.value).to.be.eql(2); @@ -105,7 +104,7 @@ describe("@Tagged", () => { class Warrior { @tagged("throwwable", false) - public weapon: IWeapon; + public weapon: Weapon; } let metadataKey = METADATA_KEY.TAGGED_PROP; @@ -126,12 +125,12 @@ describe("@Tagged", () => { expect(paramsMetadata["0"]).to.be.instanceof(Array); // assert argument at index 0 first tag - let m11: IMetadata = paramsMetadata["0"][0]; + let m11: interfaces.Metadata = paramsMetadata["0"][0]; expect(m11.key).to.be.eql("distance"); expect(m11.value).to.be.eql(1); // assert argument at index 0 second tag - let m12: IMetadata = paramsMetadata["0"][1]; + let m12: interfaces.Metadata = paramsMetadata["0"][1]; expect(m12.key).to.be.eql("power"); expect(m12.value).to.be.eql(1); @@ -139,12 +138,12 @@ describe("@Tagged", () => { expect(paramsMetadata["1"]).to.be.instanceof(Array); // assert argument at index 1 first tag - let m21: IMetadata = paramsMetadata["1"][0]; + let m21: interfaces.Metadata = paramsMetadata["1"][0]; expect(m21.key).to.be.eql("distance"); expect(m21.value).to.be.eql(5); // assert argument at index 1 second tag - let m22: IMetadata = paramsMetadata["1"][1]; + let m22: interfaces.Metadata = paramsMetadata["1"][1]; expect(m22.key).to.be.eql("power"); expect(m22.value).to.be.eql(2); @@ -181,11 +180,11 @@ describe("@Tagged", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShurien {} + interface Katana {} + interface Shurien {} let VanillaJSWarrior = (function () { - function TaggedVanillaJSWarrior(primary: IKatana, secondary: IShurien) { + function TaggedVanillaJSWarrior(primary: Katana, secondary: Shurien) { // ... } return TaggedVanillaJSWarrior; @@ -200,7 +199,7 @@ describe("@Tagged", () => { // assert metadata for first argument expect(paramsMetadata["0"]).to.be.instanceof(Array); - let m1: IMetadata = paramsMetadata["0"][0]; + let m1: interfaces.Metadata = paramsMetadata["0"][0]; expect(m1.key).to.be.eql("power"); expect(m1.value).to.be.eql(1); @@ -209,7 +208,7 @@ describe("@Tagged", () => { // assert metadata for second argument expect(paramsMetadata["1"]).to.be.instanceof(Array); - let m2: IMetadata = paramsMetadata["1"][0]; + let m2: interfaces.Metadata = paramsMetadata["1"][0]; expect(m2.key).to.be.eql("power"); expect(m2.value).to.be.eql(2); diff --git a/test/annotation/target_name.test.ts b/test/annotation/target_name.test.ts index 928475506..4add2ba60 100644 --- a/test/annotation/target_name.test.ts +++ b/test/annotation/target_name.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import { decorate } from "../../src/annotation/decorator_utils"; import targetName from "../../src/annotation/target_name"; @@ -14,12 +12,12 @@ describe("@targetName", () => { @injectable() class Warrior { - public katana: Stubs.IKatana; - public shuriken: Stubs.IShuriken; + public katana: Stubs.Katana; + public shuriken: Stubs.Shuriken; constructor( - @targetName("katana") katana: Stubs.IKatana, - @targetName("shuriken") shuriken: Stubs.IShuriken + @targetName("katana") katana: Stubs.Katana, + @targetName("shuriken") shuriken: Stubs.Shuriken ) { this.katana = katana; @@ -41,11 +39,11 @@ describe("@targetName", () => { it("Should be usable in VanillaJS applications", () => { - interface IKatana {} - interface IShurien {} + interface Katana {} + interface Shurien {} let VanillaJSWarrior = (function () { - function VanillaJSWarrior(primary: IKatana, secondary: IShurien) { + function VanillaJSWarrior(primary: Katana, secondary: Shurien) { // ... } return VanillaJSWarrior; diff --git a/test/bindings/binding.test.ts b/test/bindings/binding.test.ts index 934aa2d37..de5953f4f 100644 --- a/test/bindings/binding.test.ts +++ b/test/bindings/binding.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Binding from "../../src/bindings/binding"; import BindingScope from "../../src/bindings/binding_scope"; diff --git a/test/inversify.test.ts b/test/inversify.test.ts index 433446667..d08cf6ecf 100644 --- a/test/inversify.test.ts +++ b/test/inversify.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../src/interfaces/interfaces"; import { expect } from "chai"; import * as ERROR_MSGS from "../src/constants/error_msgs"; import * as Proxy from "harmony-proxy"; @@ -15,42 +14,42 @@ describe("InversifyJS", () => { it("Should be able to resolve and inject dependencies", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -62,11 +61,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IKatana").to(Katana); - kernel.bind("IShuriken").to(Shuriken); + kernel.bind("Ninja").to(Ninja); + kernel.bind("Katana").to(Katana); + kernel.bind("Shuriken").to(Shuriken); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); expect(ninja.sneak()).eql("hit!"); @@ -170,41 +169,41 @@ describe("InversifyJS", () => { it("Should be able to use Symbols as runtime identifiers", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } let TYPES = { - Katana: Symbol("IKatana"), - Ninja: Symbol("INinja"), - Shuriken: Symbol("IShuriken") + Katana: Symbol("Katana"), + Ninja: Symbol("Ninja"), + Shuriken: Symbol("Shuriken") }; @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { private _katana: Katana; private _shuriken: Shuriken; @@ -223,9 +222,9 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind(TYPES.Ninja).to(Ninja); - kernel.bind(TYPES.Katana).to(Katana); - kernel.bind(TYPES.Shuriken).to(Shuriken); + kernel.bind(TYPES.Ninja).to(Ninja); + kernel.bind(TYPES.Katana).to(Katana); + kernel.bind(TYPES.Shuriken).to(Shuriken); let ninja = kernel.get(TYPES.Ninja); @@ -236,40 +235,40 @@ describe("InversifyJS", () => { it("Should support Kernel modules", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; - public constructor(@inject("IKatana") katana: IKatana, @inject("IShuriken") shuriken: IShuriken) { + public constructor(@inject("Katana") katana: Katana, @inject("Shuriken") shuriken: Shuriken) { this._katana = katana; this._shuriken = shuriken; } @@ -279,13 +278,13 @@ describe("InversifyJS", () => { } - let warriors = new KernelModule((bind: IBind) => { - bind("INinja").to(Ninja); + let warriors = new KernelModule((bind: interfaces.Bind) => { + bind("Ninja").to(Ninja); }); - let weapons = new KernelModule((bind: IBind) => { - bind("IKatana").to(Katana); - bind("IShuriken").to(Shuriken); + let weapons = new KernelModule((bind: interfaces.Bind) => { + bind("Katana").to(Katana); + bind("Shuriken").to(Shuriken); }); let kernel = new Kernel(); @@ -293,14 +292,14 @@ describe("InversifyJS", () => { // load kernel.load(warriors, weapons); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); expect(ninja.sneak()).eql("hit!"); - let tryGetNinja = () => { kernel.get("INinja"); }; - let tryGetKatana = () => { kernel.get("IKatana"); }; - let tryGetShuruken = () => { kernel.get("IShuriken"); }; + let tryGetNinja = () => { kernel.get("Ninja"); }; + let tryGetKatana = () => { kernel.get("Katana"); }; + let tryGetShuruken = () => { kernel.get("Shuriken"); }; // unload kernel.unload(warriors); @@ -317,21 +316,21 @@ describe("InversifyJS", () => { it("Should support control over the scope of the dependencies", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { private _usageCount: number; public constructor() { this._usageCount = 0; @@ -343,7 +342,7 @@ describe("InversifyJS", () => { } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { private _shurikenCount: number; public constructor() { this._shurikenCount = 10; @@ -355,14 +354,14 @@ describe("InversifyJS", () => { } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -374,17 +373,17 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IKatana").to(Katana).inSingletonScope(); - kernel.bind("IShuriken").to(Shuriken); + kernel.bind("Ninja").to(Ninja); + kernel.bind("Katana").to(Katana).inSingletonScope(); + kernel.bind("Shuriken").to(Shuriken); - let ninja1 = kernel.get("INinja"); + let ninja1 = kernel.get("Ninja"); expect(ninja1.fight()).eql(`This katana was used 1 times!`); expect(ninja1.fight()).eql(`This katana was used 2 times!`); expect(ninja1.sneak()).eql(`Only 9 items left!`); expect(ninja1.sneak()).eql(`Only 8 items left!`); - let ninja2 = kernel.get("INinja"); + let ninja2 = kernel.get("Ninja"); expect(ninja2.fight()).eql(`This katana was used 3 times!`); expect(ninja2.sneak()).eql(`Only 9 items left!`); @@ -392,18 +391,18 @@ describe("InversifyJS", () => { it("Should support the injection of constant values", () => { - interface IHero { + interface Warrior { name: string; } const TYPES = { - IHero: "IHero" + Warrior: "Warrior" }; let heroName = "superman"; @injectable() - class Hero implements IHero { + class Hero implements Warrior { public name: string; public constructor() { this.name = heroName; @@ -411,8 +410,8 @@ describe("InversifyJS", () => { } const kernel = new Kernel(); - kernel.bind(TYPES.IHero).toConstantValue(new Hero()); - let hero = kernel.get(TYPES.IHero); + kernel.bind(TYPES.Warrior).toConstantValue(new Hero()); + let hero = kernel.get(TYPES.Warrior); expect(hero.name).eql(heroName); @@ -420,12 +419,12 @@ describe("InversifyJS", () => { it("Should support the injection of dynamic values", () => { - interface IUseDate { + interface UseDate { doSomething(): Date; } @injectable() - class UseDate implements IUseDate { + class UseDate implements UseDate { public currentDate: Date; public constructor(@inject("Date") currentDate: Date) { this.currentDate = currentDate; @@ -436,138 +435,138 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("IUseDate").to(UseDate); + kernel.bind("UseDate").to(UseDate); kernel.bind("Date").toDynamicValue(() => { return new Date(); }); - let subject1 = kernel.get("IUseDate"); - let subject2 = kernel.get("IUseDate"); + let subject1 = kernel.get("UseDate"); + let subject2 = kernel.get("UseDate"); expect(subject1.doSomething() === subject2.doSomething()).eql(false); kernel.unbind("Date"); kernel.bind("Date").toConstantValue(new Date()); - let subject3 = kernel.get("IUseDate"); - let subject4 = kernel.get("IUseDate"); + let subject3 = kernel.get("UseDate"); + let subject4 = kernel.get("UseDate"); expect(subject3.doSomething() === subject4.doSomething()).eql(true); }); it("Should support the injection of Functions", () => { - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaFactoryId = "KatanaFactory"; + let ninjaId = "Ninja"; + let longDistanceWeaponId = "LongDistanceWeapon"; + let shortDistanceWeaponFactoryId = "ShortDistanceWeaponFactory"; - interface KatanaFactory extends Function { - (): IKatana; + interface ShortDistanceWeaponFactory extends Function { + (): ShortDistanceWeapon; } - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface ShortDistanceWeapon { + handler: KatanaHandler; + blade: KatanaBlade; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; - public constructor(handler: IKatanaHandler, blade: IKatanaBlade) { + class Katana implements ShortDistanceWeapon { + public handler: KatanaHandler; + public blade: KatanaBlade; + public constructor(handler: KatanaHandler, blade: KatanaBlade) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface LongDistanceWeapon {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements LongDistanceWeapon {} - interface INinja { - katanaFactory: KatanaFactory; - shuriken: IShuriken; + interface Warripr { + shortDistanceWeaponFactory: ShortDistanceWeaponFactory; + longDistanceWeapon: LongDistanceWeapon; } @injectable() - class Ninja implements INinja { - public katanaFactory: KatanaFactory; - public shuriken: IShuriken; + class Ninja implements Warripr { + public shortDistanceWeaponFactory: ShortDistanceWeaponFactory; + public longDistanceWeapon: LongDistanceWeapon; public constructor( - @inject(katanaFactoryId) @targetName("katana") katanaFactory: KatanaFactory, - @inject(shurikenId) @targetName("shuriken") shuriken: IShuriken + @inject(shortDistanceWeaponFactoryId) @targetName("katana") shortDistanceWeaponFactory: ShortDistanceWeaponFactory, + @inject(longDistanceWeaponId) @targetName("shuriken") longDistanceWeapon: LongDistanceWeapon ) { - this.katanaFactory = katanaFactory; - this.shuriken = shuriken; + this.shortDistanceWeaponFactory = shortDistanceWeaponFactory; + this.longDistanceWeapon = longDistanceWeapon; } } let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(longDistanceWeaponId).to(Shuriken); let katanaFactory = function() { return new Katana(new KatanaHandler(), new KatanaBlade()); }; - kernel.bind(katanaFactoryId).toFunction(katanaFactory); // IMPORTANT! - let ninja = kernel.get(ninjaId); + kernel.bind(shortDistanceWeaponFactoryId).toFunction(katanaFactory); // IMPORTANT! + let ninja = kernel.get(ninjaId); expect(ninja instanceof Ninja).eql(true); - expect(typeof ninja.katanaFactory === "function").eql(true); - expect(ninja.katanaFactory() instanceof Katana).eql(true); - expect(ninja.katanaFactory().handler instanceof KatanaHandler).eql(true); - expect(ninja.katanaFactory().blade instanceof KatanaBlade).eql(true); - expect(ninja.shuriken instanceof Shuriken).eql(true); + expect(typeof ninja.shortDistanceWeaponFactory === "function").eql(true); + expect(ninja.shortDistanceWeaponFactory() instanceof Katana).eql(true); + expect(ninja.shortDistanceWeaponFactory().handler instanceof KatanaHandler).eql(true); + expect(ninja.shortDistanceWeaponFactory().blade instanceof KatanaBlade).eql(true); + expect(ninja.longDistanceWeapon instanceof Shuriken).eql(true); }); it("Should support the injection of class constructors", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("INewable") katana: INewable, - @inject("IShuriken") shuriken: IShuriken + @inject("Newable") katana: interfaces.Newable, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = new Katana(); this._shuriken = shuriken; @@ -579,11 +578,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind>("INewable").toConstructor(Katana); - kernel.bind("IShuriken").to(Shuriken).inSingletonScope(); + kernel.bind("Ninja").to(Ninja); + kernel.bind>("Newable").toConstructor(Katana); + kernel.bind("Shuriken").to(Shuriken).inSingletonScope(); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); expect(ninja.sneak()).eql("hit!"); @@ -592,42 +591,42 @@ describe("InversifyJS", () => { it("Should support the injection of user defined factories", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class NinjaWithUserDefinedFactory implements INinja { + class NinjaWithUserDefinedFactory implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IFactory") katanaFactory: () => IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Factory") katanaFactory: () => Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katanaFactory(); this._shuriken = shuriken; @@ -639,16 +638,16 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(NinjaWithUserDefinedFactory); - kernel.bind("IShuriken").to(Shuriken); - kernel.bind("IKatana").to(Katana); - kernel.bind>("IFactory").toFactory((context) => { + kernel.bind("Ninja").to(NinjaWithUserDefinedFactory); + kernel.bind("Shuriken").to(Shuriken); + kernel.bind("Katana").to(Katana); + kernel.bind>("Factory").toFactory((context) => { return () => { - return context.kernel.get("IKatana"); + return context.kernel.get("Katana"); }; }); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); expect(ninja.sneak()).eql("hit!"); @@ -657,37 +656,37 @@ describe("InversifyJS", () => { it("Should support the injection of user defined factories with args", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IWeapon { + interface Weapon { use(): string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public use() { return "katana!"; } } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public use() { return "shuriken!"; } } @injectable() - class NinjaWithUserDefinedFactory implements INinja { + class NinjaWithUserDefinedFactory implements Ninja { - private _katana: IWeapon; - private _shuriken: IWeapon; + private _katana: Weapon; + private _shuriken: Weapon; public constructor( - @inject("IFactory") weaponFactory: (throwable: boolean) => IWeapon + @inject("Factory") weaponFactory: (throwable: boolean) => Weapon ) { this._katana = weaponFactory(false); this._shuriken = weaponFactory(true); @@ -699,20 +698,20 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(NinjaWithUserDefinedFactory); - kernel.bind("IWeapon").to(Shuriken).whenTargetTagged("throwable", true); - kernel.bind("IWeapon").to(Katana).whenTargetTagged("throwable", false); - kernel.bind>("IFactory").toFactory((context) => { + kernel.bind("Ninja").to(NinjaWithUserDefinedFactory); + kernel.bind("Weapon").to(Shuriken).whenTargetTagged("throwable", true); + kernel.bind("Weapon").to(Katana).whenTargetTagged("throwable", false); + kernel.bind>("Factory").toFactory((context) => { return (throwable: boolean) => { if (throwable) { - return context.kernel.getTagged("IWeapon", "throwable", true); + return context.kernel.getTagged("Weapon", "throwable", true); } else { - return context.kernel.getTagged("IWeapon", "throwable", false); + return context.kernel.getTagged("Weapon", "throwable", false); } }; }); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("katana!"); expect(ninja.sneak()).eql("shuriken!"); @@ -721,26 +720,26 @@ describe("InversifyJS", () => { it("Should support the injection of user defined factories with partial application", () => { - interface IInjectorPump {} + interface InjectorPump {} @injectable() - class InjectorPump implements IInjectorPump {} + class InjectorPump implements InjectorPump {} - interface ISparkPlugs {} + interface SparkPlugs {} @injectable() - class SparkPlugs implements ISparkPlugs {} + class SparkPlugs implements SparkPlugs {} - class IEngine { + class Engine { public displacement: number; } @injectable() - class DieselEngine implements IEngine { + class DieselEngine implements Engine { public displacement: number; - private _injectorPump: IInjectorPump; + private _injectorPump: InjectorPump; constructor( - @inject("IInjectorPump") injectorPump: IInjectorPump + @inject("InjectorPump") injectorPump: InjectorPump ) { this._injectorPump = injectorPump; this.displacement = null; @@ -748,51 +747,51 @@ describe("InversifyJS", () => { } @injectable() - class PetrolEngine implements IEngine { + class PetrolEngine implements Engine { public displacement: number; - private _sparkPlugs: ISparkPlugs; + private _sparkPlugs: SparkPlugs; constructor( - @inject("ISparkPlugs") sparkPlugs: ISparkPlugs + @inject("SparkPlugs") sparkPlugs: SparkPlugs ) { this._sparkPlugs = sparkPlugs; this.displacement = null; } } - interface ICarFactory { - createEngine(displacement: number): IEngine; + interface CarFactory { + createEngine(displacement: number): Engine; } @injectable() - class DieselCarFactory implements ICarFactory { - private _dieselFactory: (displacement: number) => IEngine ; + class DieselCarFactory implements CarFactory { + private _dieselFactory: (displacement: number) => Engine ; constructor( - @inject("IFactory") factory: (category: string) => (displacement: number) => IEngine + @inject("Factory") factory: (category: string) => (displacement: number) => Engine ) { this._dieselFactory = factory("diesel"); } - public createEngine(displacement: number): IEngine { + public createEngine(displacement: number): Engine { return this._dieselFactory(displacement); } } let kernel = new Kernel(); - kernel.bind("ISparkPlugs").to(SparkPlugs); - kernel.bind("IInjectorPump").to(InjectorPump); - kernel.bind("IEngine").to(PetrolEngine).whenTargetNamed("petrol"); - kernel.bind("IEngine").to(DieselEngine).whenTargetNamed("diesel"); + kernel.bind("SparkPlugs").to(SparkPlugs); + kernel.bind("InjectorPump").to(InjectorPump); + kernel.bind("Engine").to(PetrolEngine).whenTargetNamed("petrol"); + kernel.bind("Engine").to(DieselEngine).whenTargetNamed("diesel"); - kernel.bind>("IFactory").toFactory((context) => { + kernel.bind>("Factory").toFactory((context: interfaces.Context) => { return (named: string) => (displacement: number) => { - let engine = context.kernel.getNamed("IEngine", named); + let engine = context.kernel.getNamed("Engine", named); engine.displacement = displacement; return engine; }; }); - kernel.bind("IDieselCarFactory").to(DieselCarFactory); + kernel.bind("DieselCarFactory").to(DieselCarFactory); - let dieselCarFactory = kernel.get("IDieselCarFactory"); + let dieselCarFactory = kernel.get("DieselCarFactory"); let engine = dieselCarFactory.createEngine(300); expect(engine.displacement).eql(300); @@ -802,42 +801,42 @@ describe("InversifyJS", () => { it("Should support the injection of auto factories", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class NinjaWithAutoFactory implements INinja { + class NinjaWithAutoFactory implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IFactory") katanaAutoFactory: () => IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Factory") katanaAutoFactory: () => Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katanaAutoFactory(); this._shuriken = shuriken; @@ -849,12 +848,12 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(NinjaWithAutoFactory); - kernel.bind("IShuriken").to(Shuriken); - kernel.bind("IKatana").to(Katana); - kernel.bind>("IFactory").toAutoFactory("IKatana"); + kernel.bind("Ninja").to(NinjaWithAutoFactory); + kernel.bind("Shuriken").to(Shuriken); + kernel.bind("Katana").to(Katana); + kernel.bind>("Factory").toAutoFactory("Katana"); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("cut!"); expect(ninja.sneak()).eql("hit!"); @@ -863,30 +862,30 @@ describe("InversifyJS", () => { it("Should support the injection of providers", (done) => { - interface INinja { - katana: IKatana; - katanaProvider: IProvider; + interface Ninja { + katana: Katana; + katanaProvider: interfaces.Provider; } - interface IKatana { + interface Katana { hit(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class NinjaWithProvider implements INinja { + class NinjaWithProvider implements Ninja { - public katana: IKatana; - public katanaProvider: IProvider; + public katana: Katana; + public katanaProvider: interfaces.Provider; public constructor( - @inject("IProvider") katanaProvider: IProvider + @inject("Provider") katanaProvider: interfaces.Provider ) { this.katanaProvider = katanaProvider; this.katana = null; @@ -895,18 +894,18 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(NinjaWithProvider); - kernel.bind("IKatana").to(Katana); - kernel.bind>("IProvider").toProvider((context) => { + kernel.bind("Ninja").to(NinjaWithProvider); + kernel.bind("Katana").to(Katana); + kernel.bind>("Provider").toProvider((context: interfaces.Context) => { return () => { - return new Promise((resolve) => { - let katana = context.kernel.get("IKatana"); + return new Promise((resolve) => { + let katana = context.kernel.get("Katana"); resolve(katana); }); }; }); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); ninja.katanaProvider() .then((katana) => { @@ -920,34 +919,37 @@ describe("InversifyJS", () => { it("Should support the injection of proxied objects", () => { - interface IKatana { + let weaponId = "Weapon"; + let warriorId = "Warrior"; + + interface Weapon { use: () => void; } @injectable() - class Katana implements IKatana { + class Katana implements Weapon { public use() { return "Used Katana!"; } } - interface INinja { - katana: IKatana; + interface Warrior { + weapon: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public constructor(@inject("IKatana") katana: IKatana) { - this.katana = katana; + class Ninja implements Warrior { + public weapon: Weapon; + public constructor(@inject(weaponId) weapon: Weapon) { + this.weapon = weapon; } } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); + kernel.bind(warriorId).to(Ninja); let log: string[] = []; - kernel.bind("IKatana").to(Katana).onActivation((context: IContext, katana: IKatana) => { + kernel.bind(weaponId).to(Katana).onActivation((context: interfaces.Context, katana: Katana) => { let handler = { apply: function(target: any, thisArgument: any, argumentsList: any[]) { log.push(`Starting: ${new Date().getTime()}`); @@ -960,8 +962,8 @@ describe("InversifyJS", () => { return katana; }); - let ninja = kernel.get("INinja"); - ninja.katana.use(); + let ninja = kernel.get(warriorId); + ninja.weapon.use(); expect(log.length).eql(2); expect(log[0].indexOf(`Starting: `)).not.to.eql(-1); @@ -970,94 +972,98 @@ describe("InversifyJS", () => { }); describe("Injection of multiple values with string as keys", () => { + it("Should support the injection of multiple values", () => { - interface IWeapon { + let warriorId = "Warrior"; + let weaponId = "Weapon"; + + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; - public constructor(@multiInject("IWeapon") weapons: IWeapon[]) { + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; + public constructor(@multiInject(weaponId) weapons: Weapon[]) { this.katana = weapons[0]; this.shuriken = weapons[1]; } } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IWeapon").to(Katana); - kernel.bind("IWeapon").to(Shuriken); + kernel.bind(warriorId).to(Ninja); + kernel.bind(weaponId).to(Katana); + kernel.bind(weaponId).to(Shuriken); - let ninja = kernel.get("INinja"); + let ninja = kernel.get(warriorId); expect(ninja.katana.name).eql("Katana"); expect(ninja.shuriken.name).eql("Shuriken"); - // if only one value is bound to IWeapon + // if only one value is bound to Weapon let kernel2 = new Kernel(); - kernel2.bind("INinja").to(Ninja); - kernel2.bind("IWeapon").to(Katana); + kernel2.bind(warriorId).to(Ninja); + kernel2.bind(weaponId).to(Katana); - let ninja2 = kernel2.get("INinja"); + let ninja2 = kernel2.get(warriorId); expect(ninja2.katana.name).eql("Katana"); }); it("Should support the injection of multiple values with nested inject", () => { - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -1068,18 +1074,18 @@ describe("InversifyJS", () => { } - interface INinjaSchool { - ninjaMaster: INinja; - student: INinja; + interface School { + ninjaMaster: Ninja; + student: Ninja; } @injectable() - class NinjaSchool implements INinjaSchool { - public ninjaMaster: INinja; - public student: INinja; + class NinjaSchool implements School { + public ninjaMaster: Ninja; + public student: Ninja; constructor( - @multiInject("INinja") ninja: INinja[] + @multiInject("Ninja") ninja: Ninja[] ) { this.ninjaMaster = ninja[0]; this.student = ninja[1]; @@ -1087,13 +1093,13 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("IKatana").to(Katana); - kernel.bind("IShuriken").to(Shuriken); - kernel.bind("INinja").to(Ninja); - kernel.bind("INinja").to(Ninja); - kernel.bind("INinjaSchool").to(NinjaSchool); + kernel.bind("Katana").to(Katana); + kernel.bind("Shuriken").to(Shuriken); + kernel.bind("Ninja").to(Ninja); + kernel.bind("Ninja").to(Ninja); + kernel.bind("School").to(NinjaSchool); - let ninjaSchool = kernel.get("INinjaSchool"); + let ninjaSchool = kernel.get("School"); expect(ninjaSchool.ninjaMaster.fight()).eql("cut!"); expect(ninjaSchool.ninjaMaster.sneak()).eql("hit!"); @@ -1104,42 +1110,48 @@ describe("InversifyJS", () => { it("Should support the injection of multiple values with nested multiInject", () => { - interface INinja { + let warriorId = "Warrior"; + let swordId = "Sword"; + let shurikenId = "Shuriken"; + let schoolId = "School"; + let organisationId = "Organisation"; + + interface Warrior { fight(): string; sneak(): string; } - interface IKatana { + interface Sword { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Sword { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Warrior { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Sword; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject(swordId) katana: Sword, + @inject(shurikenId) shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -1150,49 +1162,50 @@ describe("InversifyJS", () => { } - interface INinjaSchool { - ninjaMaster: INinja; - student: INinja; + interface School { + ninjaMaster: Warrior; + student: Warrior; } @injectable() - class NinjaSchool implements INinjaSchool { - public ninjaMaster: INinja; - public student: INinja; + class NinjaSchool implements School { + + public ninjaMaster: Warrior; + public student: Warrior; constructor( - @multiInject("INinja") ninjas: INinja[] + @multiInject(warriorId) ninjas: Ninja[] ) { this.ninjaMaster = ninjas[0]; this.student = ninjas[1]; } } - interface INinjaOrganisation { - schools: INinjaSchool[]; + interface Organisation { + schools: School[]; } @injectable() - class NinjaOrganisation implements INinjaOrganisation { - public schools: INinjaSchool[]; + class NinjaOrganisation implements Organisation { + public schools: School[]; constructor( - @multiInject("INinjaSchool") schools: INinjaSchool[] + @multiInject(schoolId) schools: School[] ) { this.schools = schools; } } let kernel = new Kernel(); - kernel.bind("IKatana").to(Katana); - kernel.bind("IShuriken").to(Shuriken); - kernel.bind("INinja").to(Ninja); - kernel.bind("INinja").to(Ninja); - kernel.bind("INinjaSchool").to(NinjaSchool); - kernel.bind("INinjaSchool").to(NinjaSchool); - kernel.bind("INinjaOrganisation").to(NinjaOrganisation); + kernel.bind(swordId).to(Katana); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(warriorId).to(Ninja); + kernel.bind(warriorId).to(Ninja); + kernel.bind(schoolId).to(NinjaSchool); + kernel.bind(schoolId).to(NinjaSchool); + kernel.bind(organisationId).to(NinjaOrganisation); - let ninjaOrganisation = kernel.get("INinjaOrganisation"); + let ninjaOrganisation = kernel.get(organisationId); for (let i = 0; i < 2; i++) { expect(ninjaOrganisation.schools[i].ninjaMaster.fight()).eql("cut!"); @@ -1247,7 +1260,7 @@ describe("InversifyJS", () => { expect(ninja.katana.name).eql("Katana"); expect(ninja.shuriken.name).eql("Shuriken"); - // if only one value is bound to IWeapon + // if only one value is bound to Weapon let kernel2 = new Kernel(); kernel2.bind(Ninja).to(Ninja); kernel2.bind(Weapon).to(Katana); @@ -1406,54 +1419,54 @@ describe("InversifyJS", () => { it("Should support the injection of multiple values when using Symbols as keys", () => { let TYPES = { - INinja: Symbol("INinja"), - IWeapon: Symbol("IWeapon") + Warrior: Symbol("Warrior"), + Weapon: Symbol("Weapon") }; - interface IWeapon { + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; - public constructor(@multiInject(TYPES.IWeapon) weapons: IWeapon[]) { + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; + public constructor(@multiInject(TYPES.Weapon) weapons: Weapon[]) { this.katana = weapons[0]; this.shuriken = weapons[1]; } } let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(Ninja); - kernel.bind(TYPES.IWeapon).to(Katana); - kernel.bind(TYPES.IWeapon).to(Shuriken); + kernel.bind(TYPES.Warrior).to(Ninja); + kernel.bind(TYPES.Weapon).to(Katana); + kernel.bind(TYPES.Weapon).to(Shuriken); - let ninja = kernel.get(TYPES.INinja); + let ninja = kernel.get(TYPES.Warrior); expect(ninja.katana.name).eql("Katana"); expect(ninja.shuriken.name).eql("Shuriken"); - // if only one value is bound to IWeapon + // if only one value is bound to Weapon let kernel2 = new Kernel(); - kernel2.bind(TYPES.INinja).to(Ninja); - kernel2.bind(TYPES.IWeapon).to(Katana); + kernel2.bind(TYPES.Warrior).to(Ninja); + kernel2.bind(TYPES.Weapon).to(Katana); - let ninja2 = kernel2.get(TYPES.INinja); + let ninja2 = kernel2.get(TYPES.Warrior); expect(ninja2.katana.name).eql("Katana"); }); @@ -1461,48 +1474,48 @@ describe("InversifyJS", () => { it("Should support the injection of multiple values with nested inject", () => { let TYPES = { - IKatana: Symbol("IKatana"), - INinja: Symbol("INinja"), - INinjaSchool: Symbol("INinjaSchool"), - IShuriken: Symbol("IShuriken"), + Katana: Symbol("Katana"), + Ninja: Symbol("Ninja"), + School: Symbol("School"), + Shuriken: Symbol("Shuriken"), }; - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject(TYPES.IKatana) katana: IKatana, - @inject(TYPES.IShuriken) shuriken: IShuriken + @inject(TYPES.Katana) katana: Katana, + @inject(TYPES.Shuriken) shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -1513,18 +1526,18 @@ describe("InversifyJS", () => { } - interface INinjaSchool { - ninjaMaster: INinja; - student: INinja; + interface School { + ninjaMaster: Ninja; + student: Ninja; } @injectable() - class NinjaSchool implements INinjaSchool { - public ninjaMaster: INinja; - public student: INinja; + class NinjaSchool implements School { + public ninjaMaster: Ninja; + public student: Ninja; constructor( - @multiInject(TYPES.INinja) ninja: INinja[] + @multiInject(TYPES.Ninja) ninja: Ninja[] ) { this.ninjaMaster = ninja[0]; this.student = ninja[1]; @@ -1532,13 +1545,13 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind(TYPES.IKatana).to(Katana); - kernel.bind(TYPES.IShuriken).to(Shuriken); - kernel.bind(TYPES.INinja).to(Ninja); - kernel.bind(TYPES.INinja).to(Ninja); - kernel.bind(TYPES.INinjaSchool).to(NinjaSchool); + kernel.bind(TYPES.Katana).to(Katana); + kernel.bind(TYPES.Shuriken).to(Shuriken); + kernel.bind(TYPES.Ninja).to(Ninja); + kernel.bind(TYPES.Ninja).to(Ninja); + kernel.bind(TYPES.School).to(NinjaSchool); - let ninjaSchool = kernel.get(TYPES.INinjaSchool); + let ninjaSchool = kernel.get(TYPES.School); expect(ninjaSchool.ninjaMaster.fight()).eql("cut!"); expect(ninjaSchool.ninjaMaster.sneak()).eql("hit!"); @@ -1550,49 +1563,49 @@ describe("InversifyJS", () => { it("Should support the injection of multiple values with nested multiInject", () => { let TYPES = { - IKatana: Symbol("IKatana"), - INinja: Symbol("INinja"), - INinjaOrganisation: Symbol("INinjaOrganisation"), - INinjaSchool: Symbol("INinjaSchool"), - IShuriken: Symbol("IShuriken"), + Katana: Symbol("Katana"), + Ninja: Symbol("Ninja"), + Organisation: Symbol("Organisation"), + School: Symbol("School"), + Shuriken: Symbol("Shuriken"), }; - interface INinja { + interface Ninja { fight(): string; sneak(): string; } - interface IKatana { + interface Katana { hit(): string; } - interface IShuriken { + interface Shuriken { throw(): string; } @injectable() - class Katana implements IKatana { + class Katana implements Katana { public hit() { return "cut!"; } } @injectable() - class Shuriken implements IShuriken { + class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject(TYPES.IKatana) katana: IKatana, - @inject(TYPES.IShuriken) shuriken: IShuriken + @inject(TYPES.Katana) katana: Katana, + @inject(TYPES.Shuriken) shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -1603,49 +1616,49 @@ describe("InversifyJS", () => { } - interface INinjaSchool { - ninjaMaster: INinja; - student: INinja; + interface School { + ninjaMaster: Ninja; + student: Ninja; } @injectable() - class NinjaSchool implements INinjaSchool { - public ninjaMaster: INinja; - public student: INinja; + class NinjaSchool implements School { + public ninjaMaster: Ninja; + public student: Ninja; constructor( - @multiInject(TYPES.INinja) ninjas: INinja[] + @multiInject(TYPES.Ninja) ninjas: Ninja[] ) { this.ninjaMaster = ninjas[0]; this.student = ninjas[1]; } } - interface INinjaOrganisation { - schools: INinjaSchool[]; + interface Organisation { + schools: NinjaSchool[]; } @injectable() - class NinjaOrganisation implements INinjaOrganisation { - public schools: INinjaSchool[]; + class NinjaOrganisation implements Organisation { + public schools: NinjaSchool[]; constructor( - @multiInject(TYPES.INinjaSchool) schools: INinjaSchool[] + @multiInject(TYPES.School) schools: School[] ) { this.schools = schools; } } let kernel = new Kernel(); - kernel.bind(TYPES.IKatana).to(Katana); - kernel.bind(TYPES.IShuriken).to(Shuriken); - kernel.bind(TYPES.INinja).to(Ninja); - kernel.bind(TYPES.INinja).to(Ninja); - kernel.bind(TYPES.INinjaSchool).to(NinjaSchool); - kernel.bind(TYPES.INinjaSchool).to(NinjaSchool); - kernel.bind(TYPES.INinjaOrganisation).to(NinjaOrganisation); + kernel.bind(TYPES.Katana).to(Katana); + kernel.bind(TYPES.Shuriken).to(Shuriken); + kernel.bind(TYPES.Ninja).to(Ninja); + kernel.bind(TYPES.Ninja).to(Ninja); + kernel.bind(TYPES.School).to(NinjaSchool); + kernel.bind(TYPES.School).to(NinjaSchool); + kernel.bind(TYPES.Organisation).to(NinjaOrganisation); - let ninjaOrganisation = kernel.get(TYPES.INinjaOrganisation); + let ninjaOrganisation = kernel.get(TYPES.Organisation); for (let i = 0; i < 2; i++) { expect(ninjaOrganisation.schools[i].ninjaMaster.fight()).eql("cut!"); @@ -1659,26 +1672,26 @@ describe("InversifyJS", () => { it("Should support tagged bindings", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @tagged("canThrow", false) katana: IWeapon, - @inject("IWeapon") @tagged("canThrow", true) shuriken: IWeapon + @inject("Weapon") @tagged("canThrow", false) katana: Weapon, + @inject("Weapon") @tagged("canThrow", true) shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -1686,11 +1699,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IWeapon").to(Katana).whenTargetTagged("canThrow", false); - kernel.bind("IWeapon").to(Shuriken).whenTargetTagged("canThrow", true); + kernel.bind("Warrior").to(Ninja); + kernel.bind("Weapon").to(Katana).whenTargetTagged("canThrow", false); + kernel.bind("Weapon").to(Shuriken).whenTargetTagged("canThrow", true); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Warrior"); expect(ninja.katana instanceof Katana).eql(true); expect(ninja.shuriken instanceof Shuriken).eql(true); @@ -1698,29 +1711,29 @@ describe("InversifyJS", () => { it("Should support custom tag decorators", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } let throwable = tagged("canThrow", true); let notThrowable = tagged("canThrow", false); @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @notThrowable katana: IWeapon, - @inject("IWeapon") @throwable shuriken: IWeapon + @inject("Weapon") @notThrowable katana: Weapon, + @inject("Weapon") @throwable shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -1728,11 +1741,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IWeapon").to(Katana).whenTargetTagged("canThrow", false); - kernel.bind("IWeapon").to(Shuriken).whenTargetTagged("canThrow", true); + kernel.bind("Warrior").to(Ninja); + kernel.bind("Weapon").to(Katana).whenTargetTagged("canThrow", false); + kernel.bind("Weapon").to(Shuriken).whenTargetTagged("canThrow", true); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Warrior"); expect(ninja.katana instanceof Katana).eql(true); expect(ninja.shuriken instanceof Shuriken).eql(true); @@ -1740,26 +1753,26 @@ describe("InversifyJS", () => { it("Should support named bindings", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @named("strong") katana: IWeapon, - @inject("IWeapon") @named("weak") shuriken: IWeapon + @inject("Weapon") @named("strong") katana: Weapon, + @inject("Weapon") @named("weak") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -1767,11 +1780,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IWeapon").to(Katana).whenTargetNamed("strong"); - kernel.bind("IWeapon").to(Shuriken).whenTargetNamed("weak"); + kernel.bind("Warrior").to(Ninja); + kernel.bind("Weapon").to(Katana).whenTargetNamed("strong"); + kernel.bind("Weapon").to(Shuriken).whenTargetNamed("weak"); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Warrior"); expect(ninja.katana instanceof Katana).eql(true); expect(ninja.shuriken instanceof Shuriken).eql(true); @@ -1779,26 +1792,26 @@ describe("InversifyJS", () => { it("Should support contextual bindings and targetName annotation", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @targetName("katana") katana: IWeapon, - @inject("IWeapon") @targetName("shuriken") shuriken: IWeapon + @inject("Weapon") @targetName("katana") katana: Weapon, + @inject("Weapon") @targetName("shuriken") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -1806,17 +1819,17 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); + kernel.bind("Warrior").to(Ninja); - kernel.bind("IWeapon").to(Katana).when((request: IRequest) => { + kernel.bind("Weapon").to(Katana).when((request: interfaces.Request) => { return request.target.name.equals("katana"); }); - kernel.bind("IWeapon").to(Shuriken).when((request: IRequest) => { + kernel.bind("Weapon").to(Shuriken).when((request: interfaces.Request) => { return request.target.name.equals("shuriken"); }); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Warrior"); expect(ninja.katana instanceof Katana).eql(true); expect(ninja.shuriken instanceof Shuriken).eql(true); @@ -1824,18 +1837,18 @@ describe("InversifyJS", () => { it("Should throw if circular dependencies found", () => { - interface IA {} - interface IB {} - interface IC {} - interface ID {} + interface A {} + interface B {} + interface C {} + interface D {} @injectable() - class A implements IA { - public b: IB; - public c: IC; + class A implements A { + public b: B; + public c: C; public constructor( - @inject("IB") b: IB, - @inject("IC") c: IC + @inject("B") b: B, + @inject("C") c: C ) { this.b = b; this.c = c; @@ -1843,47 +1856,47 @@ describe("InversifyJS", () => { } @injectable() - class B implements IB {} + class B implements B {} @injectable() - class C implements IC { - public d: ID; - public constructor(@inject("ID") d: ID) { + class C implements C { + public d: D; + public constructor(@inject("D") d: D) { this.d = d; } } @injectable() - class D implements ID { - public a: IA; - public constructor(@inject("IA") a: IA) { + class D implements D { + public a: A; + public constructor(@inject("A") a: A) { this.a = a; } } let kernel = new Kernel(); - kernel.bind("IA").to(A); - kernel.bind("IB").to(B); - kernel.bind("IC").to(C); - kernel.bind("ID").to(D); + kernel.bind("A").to(A); + kernel.bind("B").to(B); + kernel.bind("C").to(C); + kernel.bind("D").to(D); function willThrow() { - let a = kernel.get("IA"); + let a = kernel.get("A"); return a; } - expect(willThrow).to.throw(`${ERROR_MSGS.CIRCULAR_DEPENDENCY} IA and ID`); + expect(willThrow).to.throw(`${ERROR_MSGS.CIRCULAR_DEPENDENCY} A and D`); }); it("Should be able to resolve a ambiguous binding by providing a named tag", () => { - interface IWeapon { + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name: string; public constructor() { this.name = "katana"; @@ -1891,7 +1904,7 @@ describe("InversifyJS", () => { } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name: string; public constructor() { this.name = "shuriken"; @@ -1899,11 +1912,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("IWeapon").to(Katana).whenTargetNamed("japonese"); - kernel.bind("IWeapon").to(Shuriken).whenTargetNamed("chinese"); + kernel.bind("Weapon").to(Katana).whenTargetNamed("japonese"); + kernel.bind("Weapon").to(Shuriken).whenTargetNamed("chinese"); - let katana = kernel.getNamed("IWeapon", "japonese"); - let shuriken = kernel.getNamed("IWeapon", "chinese"); + let katana = kernel.getNamed("Weapon", "japonese"); + let shuriken = kernel.getNamed("Weapon", "chinese"); expect(katana.name).eql("katana"); expect(shuriken.name).eql("shuriken"); @@ -1912,12 +1925,12 @@ describe("InversifyJS", () => { it("Should be able to resolve a ambiguous binding by providing a custom tag", () => { - interface IWeapon { + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name: string; public constructor() { this.name = "katana"; @@ -1925,7 +1938,7 @@ describe("InversifyJS", () => { } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name: string; public constructor() { this.name = "shuriken"; @@ -1933,11 +1946,11 @@ describe("InversifyJS", () => { } let kernel = new Kernel(); - kernel.bind("IWeapon").to(Katana).whenTargetTagged("faction", "samurai"); - kernel.bind("IWeapon").to(Shuriken).whenTargetTagged("faction", "ninja"); + kernel.bind("Weapon").to(Katana).whenTargetTagged("faction", "samurai"); + kernel.bind("Weapon").to(Shuriken).whenTargetTagged("faction", "ninja"); - let katana = kernel.getTagged("IWeapon", "faction", "samurai"); - let shuriken = kernel.getTagged("IWeapon", "faction", "ninja"); + let katana = kernel.getTagged("Weapon", "faction", "samurai"); + let shuriken = kernel.getTagged("Weapon", "faction", "ninja"); expect(katana.name).eql("katana"); expect(shuriken.name).eql("shuriken"); @@ -1947,22 +1960,22 @@ describe("InversifyJS", () => { it("Should be able to inject into a super constructor", () => { const SYMBOLS = { - ISamurai: Symbol("ISamurai"), - ISamuraiMaster: Symbol("ISamuraiMaster"), - ISamuraiMaster2: Symbol("ISamuraiMaster2"), - IWeapon: Symbol("IWeapon") + Samurai: Symbol("Samurai"), + SamuraiMaster: Symbol("SamuraiMaster"), + SamuraiMaster2: Symbol("SamuraiMaster2"), + Weapon: Symbol("Weapon") }; - interface IWeapon { + interface Weapon { name: string; } - interface IWarrior { - weapon: IWeapon; + interface Warrior { + weapon: Weapon; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name: string; public constructor() { this.name = "katana"; @@ -1970,11 +1983,11 @@ describe("InversifyJS", () => { } @injectable() - class Samurai implements IWarrior { + class Samurai implements Warrior { - public weapon: IWeapon; + public weapon: Weapon; - public constructor(weapon: IWeapon) { + public constructor(weapon: Weapon) { this.weapon = weapon; } } @@ -1982,30 +1995,30 @@ describe("InversifyJS", () => { // Important: derived classes constructor must be manually implemented and annotated // Therefore the following will fail @injectable() - class SamuraiMaster extends Samurai implements IWarrior { + class SamuraiMaster extends Samurai implements Warrior { public isMaster: boolean; } // However, he following will work @injectable() - class SamuraiMaster2 extends Samurai implements IWarrior { + class SamuraiMaster2 extends Samurai implements Warrior { public isMaster: boolean; - public constructor(@inject(SYMBOLS.IWeapon) weapon: IWeapon) { + public constructor(@inject(SYMBOLS.Weapon) weapon: Weapon) { super(weapon); this.isMaster = true; } } const kernel = new Kernel(); - kernel.bind(SYMBOLS.IWeapon).to(Katana); - kernel.bind(SYMBOLS.ISamurai).to(Samurai); - kernel.bind(SYMBOLS.ISamuraiMaster).to(SamuraiMaster); - kernel.bind(SYMBOLS.ISamuraiMaster2).to(SamuraiMaster2); + kernel.bind(SYMBOLS.Weapon).to(Katana); + kernel.bind(SYMBOLS.Samurai).to(Samurai); + kernel.bind(SYMBOLS.SamuraiMaster).to(SamuraiMaster); + kernel.bind(SYMBOLS.SamuraiMaster2).to(SamuraiMaster2); - let errorFunction = () => { kernel.get(SYMBOLS.ISamuraiMaster); }; + let errorFunction = () => { kernel.get(SYMBOLS.SamuraiMaster); }; expect(errorFunction).to.throw(`${ERROR_MSGS.MISSING_EXPLICIT_CONSTRUCTOR} SamuraiMaster.`); - let samuraiMaster2 = kernel.get(SYMBOLS.ISamuraiMaster2); + let samuraiMaster2 = kernel.get(SYMBOLS.SamuraiMaster2); expect(samuraiMaster2.weapon.name).eql("katana"); expect(typeof (samuraiMaster2).isMaster).eql("boolean"); @@ -2014,16 +2027,16 @@ describe("InversifyJS", () => { it("Should support a whenInjectedInto contextual bindings constraint", () => { let TYPES = { - INinja: "INinja", - IWeapon: "IWeapon" + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IWeapon { + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name: string; public constructor() { this.name = "katana"; @@ -2031,49 +2044,49 @@ describe("InversifyJS", () => { } @injectable() - class Bokken implements IWeapon { + class Bokken implements Weapon { public name: string; public constructor() { this.name = "bokken"; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @targetName("weapon") weapon: IWeapon + @inject("Weapon") @targetName("weapon") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @targetName("weapon") weapon: IWeapon + @inject("Weapon") @targetName("weapon") weapon: Weapon ) { this.weapon = weapon; } } let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel.bind(TYPES.IWeapon).to(Katana).whenInjectedInto(NinjaMaster); - kernel.bind(TYPES.IWeapon).to(Bokken).whenInjectedInto(NinjaStudent); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel.bind(TYPES.Weapon).to(Katana).whenInjectedInto(NinjaMaster); + kernel.bind(TYPES.Weapon).to(Bokken).whenInjectedInto(NinjaStudent); - let master = kernel.getTagged(TYPES.INinja, "master", true); - let student = kernel.getTagged(TYPES.INinja, "master", false); + let master = kernel.getTagged(TYPES.Ninja, "master", true); + let student = kernel.getTagged(TYPES.Ninja, "master", false); expect(master instanceof NinjaMaster).eql(true); expect(student instanceof NinjaStudent).eql(true); @@ -2086,17 +2099,17 @@ describe("InversifyJS", () => { it("Should support a whenParentNamed contextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2104,62 +2117,62 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @named("non-lethal") weapon: IWeapon + @inject("Weapon") @named("non-lethal") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @named("lethal") weapon: IWeapon + @inject("Weapon") @named("lethal") weapon: Weapon ) { this.weapon = weapon; } } let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenParentNamed("lethal"); - kernel.bind(TYPES.IMaterial).to(Wood).whenParentNamed("non-lethal"); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenParentNamed("lethal"); + kernel.bind(TYPES.Material).to(Wood).whenParentNamed("non-lethal"); - let master = kernel.getTagged(TYPES.INinja, "master", true); - let student = kernel.getTagged(TYPES.INinja, "master", false); + let master = kernel.getTagged(TYPES.Ninja, "master", true); + let student = kernel.getTagged(TYPES.Ninja, "master", false); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); @@ -2169,17 +2182,17 @@ describe("InversifyJS", () => { it("Should support a whenParentTagged contextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2187,62 +2200,62 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @tagged("lethal", false) weapon: IWeapon + @inject("Weapon") @tagged("lethal", false) weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") @tagged("lethal", true) weapon: IWeapon + @inject("Weapon") @tagged("lethal", true) weapon: Weapon ) { this.weapon = weapon; } } let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenParentTagged("lethal", true); - kernel.bind(TYPES.IMaterial).to(Wood).whenParentTagged("lethal", false); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenParentTagged("lethal", true); + kernel.bind(TYPES.Material).to(Wood).whenParentTagged("lethal", false); - let master = kernel.getTagged(TYPES.INinja, "master", true); - let student = kernel.getTagged(TYPES.INinja, "master", false); + let master = kernel.getTagged(TYPES.Ninja, "master", true); + let student = kernel.getTagged(TYPES.Ninja, "master", false); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); @@ -2252,17 +2265,17 @@ describe("InversifyJS", () => { it("Should support a whenAnyAncestorIs and whenNoAncestorIs contextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2270,48 +2283,48 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } @@ -2319,28 +2332,28 @@ describe("InversifyJS", () => { // whenAnyAncestorIs let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenAnyAncestorIs(NinjaMaster); - kernel.bind(TYPES.IMaterial).to(Wood).whenAnyAncestorIs(NinjaStudent); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenAnyAncestorIs(NinjaMaster); + kernel.bind(TYPES.Material).to(Wood).whenAnyAncestorIs(NinjaStudent); - let master = kernel.getTagged(TYPES.INinja, "master", true); - let student = kernel.getTagged(TYPES.INinja, "master", false); + let master = kernel.getTagged(TYPES.Ninja, "master", true); + let student = kernel.getTagged(TYPES.Ninja, "master", false); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); // whenNoAncestorIs let kernel2 = new Kernel(); - kernel2.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel2.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel2.bind(TYPES.IWeapon).to(Sword); - kernel2.bind(TYPES.IMaterial).to(Iron).whenNoAncestorIs(NinjaStudent); - kernel2.bind(TYPES.IMaterial).to(Wood).whenNoAncestorIs(NinjaMaster); + kernel2.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel2.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel2.bind(TYPES.Weapon).to(Sword); + kernel2.bind(TYPES.Material).to(Iron).whenNoAncestorIs(NinjaStudent); + kernel2.bind(TYPES.Material).to(Wood).whenNoAncestorIs(NinjaMaster); - let master2 = kernel2.getTagged(TYPES.INinja, "master", true); - let student2 = kernel2.getTagged(TYPES.INinja, "master", false); + let master2 = kernel2.getTagged(TYPES.Ninja, "master", true); + let student2 = kernel2.getTagged(TYPES.Ninja, "master", false); expect(master2.weapon.material.name).eql("iron"); expect(student2.weapon.material.name).eql("wood"); @@ -2350,17 +2363,17 @@ describe("InversifyJS", () => { it("Should support a whenAnyAncestorNamed and whenNoAncestorNamed contextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2368,48 +2381,48 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } @@ -2417,28 +2430,28 @@ describe("InversifyJS", () => { // whenAnyAncestorNamed let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetNamed("non-lethal"); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetNamed("lethal"); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenAnyAncestorNamed("lethal"); - kernel.bind(TYPES.IMaterial).to(Wood).whenAnyAncestorNamed("non-lethal"); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetNamed("non-lethal"); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetNamed("lethal"); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenAnyAncestorNamed("lethal"); + kernel.bind(TYPES.Material).to(Wood).whenAnyAncestorNamed("non-lethal"); - let master = kernel.getNamed(TYPES.INinja, "lethal"); - let student = kernel.getNamed(TYPES.INinja, "non-lethal"); + let master = kernel.getNamed(TYPES.Ninja, "lethal"); + let student = kernel.getNamed(TYPES.Ninja, "non-lethal"); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); // whenNoAncestorNamed let kernel2 = new Kernel(); - kernel2.bind(TYPES.INinja).to(NinjaStudent).whenTargetNamed("non-lethal"); - kernel2.bind(TYPES.INinja).to(NinjaMaster).whenTargetNamed("lethal"); - kernel2.bind(TYPES.IWeapon).to(Sword); - kernel2.bind(TYPES.IMaterial).to(Iron).whenNoAncestorNamed("non-lethal"); - kernel2.bind(TYPES.IMaterial).to(Wood).whenNoAncestorNamed("lethal"); + kernel2.bind(TYPES.Ninja).to(NinjaStudent).whenTargetNamed("non-lethal"); + kernel2.bind(TYPES.Ninja).to(NinjaMaster).whenTargetNamed("lethal"); + kernel2.bind(TYPES.Weapon).to(Sword); + kernel2.bind(TYPES.Material).to(Iron).whenNoAncestorNamed("non-lethal"); + kernel2.bind(TYPES.Material).to(Wood).whenNoAncestorNamed("lethal"); - let master2 = kernel.getNamed(TYPES.INinja, "lethal"); - let student2 = kernel.getNamed(TYPES.INinja, "non-lethal"); + let master2 = kernel.getNamed(TYPES.Ninja, "lethal"); + let student2 = kernel.getNamed(TYPES.Ninja, "non-lethal"); expect(master2.weapon.material.name).eql("iron"); expect(student2.weapon.material.name).eql("wood"); @@ -2448,17 +2461,17 @@ describe("InversifyJS", () => { it("Should support a whenAnyAncestorTagged and whenNoAncestorTaggedcontextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2466,48 +2479,48 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } @@ -2515,28 +2528,28 @@ describe("InversifyJS", () => { // whenAnyAncestorTagged let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("lethal", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("lethal", true); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenAnyAncestorTagged("lethal", true); - kernel.bind(TYPES.IMaterial).to(Wood).whenAnyAncestorTagged("lethal", false); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("lethal", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("lethal", true); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenAnyAncestorTagged("lethal", true); + kernel.bind(TYPES.Material).to(Wood).whenAnyAncestorTagged("lethal", false); - let master = kernel.getTagged(TYPES.INinja, "lethal", true); - let student = kernel.getTagged(TYPES.INinja, "lethal", false); + let master = kernel.getTagged(TYPES.Ninja, "lethal", true); + let student = kernel.getTagged(TYPES.Ninja, "lethal", false); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); // whenNoAncestorTagged let kernel2 = new Kernel(); - kernel2.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("lethal", false); - kernel2.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("lethal", true); - kernel2.bind(TYPES.IWeapon).to(Sword); - kernel2.bind(TYPES.IMaterial).to(Iron).whenNoAncestorTagged("lethal", false); - kernel2.bind(TYPES.IMaterial).to(Wood).whenNoAncestorTagged("lethal", true); + kernel2.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("lethal", false); + kernel2.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("lethal", true); + kernel2.bind(TYPES.Weapon).to(Sword); + kernel2.bind(TYPES.Material).to(Iron).whenNoAncestorTagged("lethal", false); + kernel2.bind(TYPES.Material).to(Wood).whenNoAncestorTagged("lethal", true); - let master2 = kernel.getTagged(TYPES.INinja, "lethal", true); - let student2 = kernel.getTagged(TYPES.INinja, "lethal", false); + let master2 = kernel.getTagged(TYPES.Ninja, "lethal", true); + let student2 = kernel.getTagged(TYPES.Ninja, "lethal", false); expect(master2.weapon.material.name).eql("iron"); expect(student2.weapon.material.name).eql("wood"); @@ -2546,17 +2559,17 @@ describe("InversifyJS", () => { it("Should support a whenAnyAncestorMatches and whenNoAncestorMatches contextual bindings constraint", () => { let TYPES = { - IMaterial: "IMaterial", - INinja: "INinja", - IWeapon: "IWeapon" + Material: "Material", + Ninja: "Ninja", + Weapon: "Weapon" }; - interface IMaterial { + interface Material { name: string; } @injectable() - class Wood implements IMaterial { + class Wood implements Material { public name: string; public constructor() { this.name = "wood"; @@ -2564,48 +2577,48 @@ describe("InversifyJS", () => { } @injectable() - class Iron implements IMaterial { + class Iron implements Material { public name: string; public constructor() { this.name = "iron"; } } - interface IWeapon { - material: IMaterial; + interface Weapon { + material: Material; } @injectable() - class Sword implements IWeapon { - public material: IMaterial; - public constructor(@inject("IMaterial") material: IMaterial) { + class Sword implements Weapon { + public material: Material; + public constructor(@inject("Material") material: Material) { this.material = material; } } - interface INinja { - weapon: IWeapon; + interface Ninja { + weapon: Weapon; } @injectable() - class NinjaStudent implements INinja { + class NinjaStudent implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } } @injectable() - class NinjaMaster implements INinja { + class NinjaMaster implements Ninja { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } @@ -2617,28 +2630,28 @@ describe("InversifyJS", () => { // whenAnyAncestorMatches let kernel = new Kernel(); - kernel.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IMaterial).to(Iron).whenAnyAncestorMatches(anyAncestorIsNinjaMasterConstraint); - kernel.bind(TYPES.IMaterial).to(Wood).whenAnyAncestorMatches(anyAncestorIsNinjaStudentConstraint); + kernel.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Material).to(Iron).whenAnyAncestorMatches(anyAncestorIsNinjaMasterConstraint); + kernel.bind(TYPES.Material).to(Wood).whenAnyAncestorMatches(anyAncestorIsNinjaStudentConstraint); - let master = kernel.getTagged(TYPES.INinja, "master", true); - let student = kernel.getTagged(TYPES.INinja, "master", false); + let master = kernel.getTagged(TYPES.Ninja, "master", true); + let student = kernel.getTagged(TYPES.Ninja, "master", false); expect(master.weapon.material.name).eql("iron"); expect(student.weapon.material.name).eql("wood"); // whenNoAncestorMatches let kernel2 = new Kernel(); - kernel2.bind(TYPES.INinja).to(NinjaStudent).whenTargetTagged("master", false); - kernel2.bind(TYPES.INinja).to(NinjaMaster).whenTargetTagged("master", true); - kernel2.bind(TYPES.IWeapon).to(Sword); - kernel2.bind(TYPES.IMaterial).to(Iron).whenNoAncestorMatches(anyAncestorIsNinjaStudentConstraint); - kernel2.bind(TYPES.IMaterial).to(Wood).whenNoAncestorMatches(anyAncestorIsNinjaMasterConstraint); + kernel2.bind(TYPES.Ninja).to(NinjaStudent).whenTargetTagged("master", false); + kernel2.bind(TYPES.Ninja).to(NinjaMaster).whenTargetTagged("master", true); + kernel2.bind(TYPES.Weapon).to(Sword); + kernel2.bind(TYPES.Material).to(Iron).whenNoAncestorMatches(anyAncestorIsNinjaStudentConstraint); + kernel2.bind(TYPES.Material).to(Wood).whenNoAncestorMatches(anyAncestorIsNinjaMasterConstraint); - let master2 = kernel2.getTagged(TYPES.INinja, "master", true); - let student2 = kernel2.getTagged(TYPES.INinja, "master", false); + let master2 = kernel2.getTagged(TYPES.Ninja, "master", true); + let student2 = kernel2.getTagged(TYPES.Ninja, "master", false); expect(master2.weapon.material.name).eql("iron"); expect(student2.weapon.material.name).eql("wood"); @@ -2650,13 +2663,13 @@ describe("InversifyJS", () => { let kernel = new Kernel(); let inject = makePropertyInjectDecorator(kernel); - interface ISomeService { + interface Service { count: number; increment(): void; } @injectable() - class SomeService implements ISomeService { + class SomeService implements Service { public count: number; public constructor() { this.count = 0; @@ -2667,8 +2680,8 @@ describe("InversifyJS", () => { } class SomeWebComponent { - @inject("ISomeService") - private _service: ISomeService; + @inject("Service") + private _service: Service; public doSomething() { let count = this._service.count; this._service.increment(); @@ -2676,7 +2689,7 @@ describe("InversifyJS", () => { } } - kernel.bind("ISomeService").to(SomeService); + kernel.bind("Service").to(SomeService); let someComponent = new SomeWebComponent(); expect(someComponent.doSomething()).eql(0); @@ -2694,15 +2707,15 @@ describe("InversifyJS", () => { let kernel = new Kernel(); let multiInject = makePropertyMultiInjectDecorator(kernel); - let TYPES = { IWeapon: "IWeapon" }; + let TYPES = { Weapon: "Weapon" }; - interface IWeapon { + interface Weapon { durability: number; use(): void; } @injectable() - class Sword implements IWeapon { + class Sword implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -2713,7 +2726,7 @@ describe("InversifyJS", () => { } @injectable() - class WarHammer implements IWeapon { + class WarHammer implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -2724,12 +2737,12 @@ describe("InversifyJS", () => { } class Warrior { - @multiInject(TYPES.IWeapon) - public weapons: IWeapon[]; + @multiInject(TYPES.Weapon) + public weapons: Weapon[]; } - kernel.bind(TYPES.IWeapon).to(Sword); - kernel.bind(TYPES.IWeapon).to(WarHammer); + kernel.bind(TYPES.Weapon).to(Sword); + kernel.bind(TYPES.Weapon).to(WarHammer); let warrior1 = new Warrior(); @@ -2758,21 +2771,21 @@ describe("InversifyJS", () => { let inject = makePropertyInjectDecorator(kernel); let TYPES = { - IWarrior: "IWarrior", - IWeapon: "IWeapon" + Warrior: "Warrior", + Weapon: "Weapon" }; - interface IWarrior { - weapon: IWeapon; + interface Warrior { + weapon: Weapon; } - interface IWeapon { + interface Weapon { durability: number; use(): void; } @injectable() - class Sword implements IWeapon { + class Sword implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -2783,7 +2796,7 @@ describe("InversifyJS", () => { } @injectable() - class WarHammer implements IWeapon { + class WarHammer implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -2794,16 +2807,16 @@ describe("InversifyJS", () => { } @injectable() - class Warrior implements IWarrior { - @inject(TYPES.IWeapon) - public weapon: IWeapon; + class Ninja implements Warrior { + @inject(TYPES.Weapon) + public weapon: Weapon; } - kernel.bind(TYPES.IWarrior).to(Warrior); - kernel.bind(TYPES.IWeapon).to(Sword); + kernel.bind(TYPES.Warrior).to(Ninja); + kernel.bind(TYPES.Weapon).to(Sword); // check property injection works - let warrior1 = kernel.get(TYPES.IWarrior); + let warrior1 = kernel.get(TYPES.Warrior); expect(warrior1.weapon).to.be.instanceof(Sword); expect(warrior1.weapon.durability).eql(100); warrior1.weapon.use(); @@ -2811,92 +2824,92 @@ describe("InversifyJS", () => { // check snapshot works kernel.snapshot(); - kernel.unbind(TYPES.IWeapon); - kernel.bind(TYPES.IWeapon).to(WarHammer); + kernel.unbind(TYPES.Weapon); + kernel.bind(TYPES.Weapon).to(WarHammer); expect(warrior1.weapon).to.be.instanceof(Sword); expect(warrior1.weapon.durability).eql(90); - let warrior2 = kernel.get(TYPES.IWarrior); + let warrior2 = kernel.get(TYPES.Warrior); expect(warrior2.weapon).to.be.instanceof(WarHammer); expect(warrior2.weapon.durability).eql(100); // check snapshot resore works kernel.restore(); - let warrior3 = kernel.get(TYPES.IWarrior); + let warrior3 = kernel.get(TYPES.Warrior); expect(warrior3.weapon).to.be.instanceof(Sword); expect(warrior3.weapon.durability).eql(100); // check property injection works with singletons - kernel.unbind(TYPES.IWeapon); - kernel.bind(TYPES.IWeapon).to(Sword).inSingletonScope(); + kernel.unbind(TYPES.Weapon); + kernel.bind(TYPES.Weapon).to(Sword).inSingletonScope(); - let warrior4 = kernel.get(TYPES.IWarrior); + let warrior4 = kernel.get(TYPES.Warrior); expect(warrior4.weapon).to.be.instanceof(Sword); expect(warrior4.weapon.durability).eql(100); warrior4.weapon.use(); expect(warrior4.weapon.durability).eql(90); - let warrior5 = kernel.get(TYPES.IWarrior); + let warrior5 = kernel.get(TYPES.Warrior); expect(warrior5.weapon).to.be.instanceof(Sword); expect(warrior5.weapon.durability).eql(90); // check property injection works with snapshot and singletons kernel.snapshot(); - kernel.unbind(TYPES.IWeapon); - kernel.bind(TYPES.IWeapon).to(WarHammer).inSingletonScope(); + kernel.unbind(TYPES.Weapon); + kernel.bind(TYPES.Weapon).to(WarHammer).inSingletonScope(); expect(warrior4.weapon).to.be.instanceof(Sword); expect(warrior4.weapon.durability).eql(90); expect(warrior5.weapon).to.be.instanceof(Sword); expect(warrior5.weapon.durability).eql(90); - let warrior6 = kernel.get(TYPES.IWarrior); + let warrior6 = kernel.get(TYPES.Warrior); expect(warrior6.weapon).to.be.instanceof(WarHammer); expect(warrior6.weapon.durability).eql(100); warrior6.weapon.use(); expect(warrior6.weapon.durability).eql(90); - let warrior7 = kernel.get(TYPES.IWarrior); + let warrior7 = kernel.get(TYPES.Warrior); expect(warrior7.weapon).to.be.instanceof(WarHammer); expect(warrior7.weapon.durability).eql(90); // check property injection works with restore and singletons kernel.restore(); - let warrior8 = kernel.get(TYPES.IWarrior); + let warrior8 = kernel.get(TYPES.Warrior); expect(warrior8.weapon).to.be.instanceof(Sword); expect(warrior8.weapon.durability).eql(100); warrior8.weapon.use(); expect(warrior8.weapon.durability).eql(90); - let warrior9 = kernel.get(TYPES.IWarrior); + let warrior9 = kernel.get(TYPES.Warrior); expect(warrior9.weapon).to.be.instanceof(Sword); expect(warrior9.weapon.durability).eql(90); // check property injection works with snapshot and constant value bindings kernel.snapshot(); - kernel.unbind(TYPES.IWeapon); - kernel.bind(TYPES.IWeapon).toConstantValue(new WarHammer()); + kernel.unbind(TYPES.Weapon); + kernel.bind(TYPES.Weapon).toConstantValue(new WarHammer()); - let warrior10 = kernel.get(TYPES.IWarrior); + let warrior10 = kernel.get(TYPES.Warrior); expect(warrior10.weapon).to.be.instanceof(WarHammer); expect(warrior10.weapon.durability).eql(100); warrior10.weapon.use(); expect(warrior10.weapon.durability).eql(90); - let warrior11 = kernel.get(TYPES.IWarrior); + let warrior11 = kernel.get(TYPES.Warrior); expect(warrior11.weapon).to.be.instanceof(WarHammer); expect(warrior11.weapon.durability).eql(90); // check property injection works with restore value bindings kernel.restore(); - let warrior12 = kernel.get(TYPES.IWarrior); + let warrior12 = kernel.get(TYPES.Warrior); expect(warrior12.weapon).to.be.instanceof(Sword); expect(warrior12.weapon.durability).eql(100); warrior12.weapon.use(); expect(warrior12.weapon.durability).eql(90); - let warrior13 = kernel.get(TYPES.IWarrior); + let warrior13 = kernel.get(TYPES.Warrior); expect(warrior13.weapon).to.be.instanceof(Sword); expect(warrior13.weapon.durability).eql(90); @@ -2904,7 +2917,7 @@ describe("InversifyJS", () => { it("Should display a error when injecting into an abstract class", () => { - interface IWeapon {} + interface Weapon {} @injectable() class Soldier extends Stubs.BaseSoldier {} @@ -2916,19 +2929,19 @@ describe("InversifyJS", () => { class Knight extends Stubs.BaseSoldier {} @injectable() - class Sword implements Stubs.IWeapon {} + class Sword implements Stubs.Weapon {} @injectable() - class Bow implements Stubs.IWeapon {} + class Bow implements Stubs.Weapon {} @injectable() - class DefaultWeapon implements Stubs.IWeapon {} + class DefaultWeapon implements Stubs.Weapon {} let kernel = new Kernel(); - kernel.bind("IWeapon").to(DefaultWeapon).whenInjectedInto(Soldier); - kernel.bind("IWeapon").to(Sword).whenInjectedInto(Knight); - kernel.bind("IWeapon").to(Bow).whenInjectedInto(Archer); + kernel.bind("Weapon").to(DefaultWeapon).whenInjectedInto(Soldier); + kernel.bind("Weapon").to(Sword).whenInjectedInto(Knight); + kernel.bind("Weapon").to(Bow).whenInjectedInto(Archer); kernel.bind("BaseSoldier").to(Soldier).whenTargetNamed("default"); kernel.bind("BaseSoldier").to(Knight).whenTargetNamed("knight"); kernel.bind("BaseSoldier").to(Archer).whenTargetNamed("archer"); @@ -2946,16 +2959,16 @@ describe("InversifyJS", () => { it("Should be able to inject a regular derived class", () => { const SYMBOLS = { - ISamuraiMaster: Symbol("ISamuraiMaster"), - RANK: Symbol("RANK") + RANK: Symbol("RANK"), + SamuraiMaster: Symbol("SamuraiMaster") }; - interface ISamurai { + interface Warrior { rank: string; } @injectable() - class Samurai implements ISamurai { + class Samurai implements Warrior { public rank: string; @@ -2965,17 +2978,17 @@ describe("InversifyJS", () => { } @injectable() - class SamuraiMaster extends Samurai implements ISamurai { + class SamuraiMaster extends Samurai implements Warrior { constructor(@inject(SYMBOLS.RANK) rank: string) { super(rank); } } const kernel = new Kernel(); - kernel.bind(SYMBOLS.ISamuraiMaster).to(SamuraiMaster); + kernel.bind(SYMBOLS.SamuraiMaster).to(SamuraiMaster); kernel.bind(SYMBOLS.RANK).toConstantValue("Master"); - let samurai = kernel.get(SYMBOLS.ISamuraiMaster); + let samurai = kernel.get(SYMBOLS.SamuraiMaster); expect(samurai.rank).eql("Master"); }); @@ -2983,15 +2996,15 @@ describe("InversifyJS", () => { it("Should be able to identify missing @injectable in a base class", () => { const SYMBOLS = { - ISamuraiMaster: Symbol("ISamuraiMaster") + SamuraiMaster: Symbol("SamuraiMaster") }; - interface ISamurai { + interface Warrior { rank: string; } // IMPORTANT: Missing @injectable() - class Samurai implements ISamurai { + class Samurai implements Warrior { public rank: string; @@ -3001,17 +3014,17 @@ describe("InversifyJS", () => { } @injectable() - class SamuraiMaster extends Samurai implements ISamurai { + class SamuraiMaster extends Samurai implements Warrior { constructor() { super("master"); } } const kernel = new Kernel(); - kernel.bind(SYMBOLS.ISamuraiMaster).to(SamuraiMaster); + kernel.bind(SYMBOLS.SamuraiMaster).to(SamuraiMaster); function throws() { - return kernel.get(SYMBOLS.ISamuraiMaster); + return kernel.get(SYMBOLS.SamuraiMaster); } expect(throws).to.throw(`${ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION} Samurai`); diff --git a/test/kernel/kernel.test.ts b/test/kernel/kernel.test.ts index 8d3a945b6..e6f4dd130 100644 --- a/test/kernel/kernel.test.ts +++ b/test/kernel/kernel.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Kernel from "../../src/kernel/kernel"; @@ -21,40 +20,40 @@ describe("Kernel", () => { it("Should be able to use modules as configuration", () => { - interface INinja {} - interface IKatana {} - interface IShuriken {} + interface Ninja {} + interface Katana {} + interface Shuriken {} @injectable() - class Katana implements IKatana {} + class Katana implements Katana {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} - let warriors = new KernelModule((bind: IBind) => { - bind("INinja").to(Ninja); + let warriors = new KernelModule((bind: interfaces.Bind) => { + bind("Ninja").to(Ninja); }); - let weapons = new KernelModule((bind: IBind) => { - bind("IKatana").to(Katana); - bind("IShuriken").to(Shuriken); + let weapons = new KernelModule((bind: interfaces.Bind) => { + bind("Katana").to(Katana); + bind("Shuriken").to(Shuriken); }); let kernel = new Kernel(); kernel.load(warriors, weapons); let _kernel: any = kernel; - expect(_kernel._bindingDictionary._dictionary[0].serviceIdentifier).eql("INinja"); - expect(_kernel._bindingDictionary._dictionary[1].serviceIdentifier).eql("IKatana"); - expect(_kernel._bindingDictionary._dictionary[2].serviceIdentifier).eql("IShuriken"); + expect(_kernel._bindingDictionary._dictionary[0].serviceIdentifier).eql("Ninja"); + expect(_kernel._bindingDictionary._dictionary[1].serviceIdentifier).eql("Katana"); + expect(_kernel._bindingDictionary._dictionary[2].serviceIdentifier).eql("Shuriken"); expect(_kernel._bindingDictionary._dictionary.length).eql(3); - let tryGetNinja = () => { _kernel.get("INinja"); }; - let tryGetKatana = () => { _kernel.get("IKatana"); }; - let tryGetShuruken = () => { _kernel.get("IShuriken"); }; + let tryGetNinja = () => { _kernel.get("Ninja"); }; + let tryGetKatana = () => { _kernel.get("Katana"); }; + let tryGetShuruken = () => { _kernel.get("Shuriken"); }; kernel.unload(warriors); expect(_kernel._bindingDictionary._dictionary.length).eql(2); @@ -72,14 +71,14 @@ describe("Kernel", () => { it("Should be able to store bindings", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaId = "INinja"; + class Ninja implements Ninja {} + let ninjaId = "Ninja"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(ninjaId).to(Ninja); let _kernel: any = kernel; let serviceIdentifier = _kernel._bindingDictionary._dictionary[0].serviceIdentifier; @@ -99,14 +98,14 @@ describe("Kernel", () => { it("Should unbind a binding when requested", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaId = "INinja"; + class Ninja implements Ninja {} + let ninjaId = "Ninja"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(ninjaId).to(Ninja); let _kernel: any = kernel; let serviceIdentifier = _kernel._bindingDictionary._dictionary[0].serviceIdentifier; @@ -120,35 +119,35 @@ describe("Kernel", () => { it("Should throw when cannot unbind", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} - let serviceIdentifier = "INinja"; + let serviceIdentifier = "Ninja"; let kernel = new Kernel(); - let throwFunction = () => { kernel.unbind("INinja"); }; + let throwFunction = () => { kernel.unbind("Ninja"); }; expect(throwFunction).to.throw(`${ERROR_MSGS.CANNOT_UNBIND} ${serviceIdentifier}`); }); it("Should unbind a binding when requested", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - interface ISamurai {} + class Ninja implements Ninja {} + interface Samurai {} @injectable() - class Samurai implements ISamurai {} + class Samurai implements Samurai {} - let ninjaId = "INinja"; - let samuraiId = "ISamurai"; + let ninjaId = "Ninja"; + let samuraiId = "Samurai"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(samuraiId).to(Samurai); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(samuraiId).to(Samurai); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; @@ -165,22 +164,22 @@ describe("Kernel", () => { it("Should be able unbound all dependencies", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} - interface ISamurai {} + interface Samurai {} @injectable() - class Samurai implements ISamurai {} + class Samurai implements Samurai {} - let ninjaId = "INinja"; - let samuraiId = "ISamurai"; + let ninjaId = "Ninja"; + let samuraiId = "Samurai"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(samuraiId).to(Samurai); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(samuraiId).to(Samurai); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; @@ -197,26 +196,26 @@ describe("Kernel", () => { it("Should NOT be able to get unregistered services", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaId = "INinja"; + class Ninja implements Ninja {} + let ninjaId = "Ninja"; let kernel = new Kernel(); - let throwFunction = () => { kernel.get(ninjaId); }; + let throwFunction = () => { kernel.get(ninjaId); }; expect(throwFunction).to.throw(`${ERROR_MSGS.NOT_REGISTERED} ${ninjaId}`); }); it("Should be able to get a registered and not ambiguous service", () => { - interface INinja { + interface Warrior { name: string; } @injectable() - class Ninja implements INinja { + class Ninja implements Warrior { public name: string; @@ -225,18 +224,18 @@ describe("Kernel", () => { } } - let ninjaId = "INinja"; + let warriorId = "Warrior"; let ninjaName = "Ryu Hayabusa"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(warriorId).to(Ninja); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; // pre conditions expect(dictionary.length).eql(1); - expect(dictionary[0].serviceIdentifier).eql(ninjaId); + expect(dictionary[0].serviceIdentifier).eql(warriorId); expect(dictionary[0].value.length).eql(1); // mock planner and resolver @@ -250,7 +249,7 @@ describe("Kernel", () => { let plannerCreatePlanStub = sandbox.stub(planner, "createPlan").returns(null); let resolverResolveStub = sandbox.stub(resolver, "resolve").returns(new Ninja(ninjaName)); - let ninja = kernel.get(ninjaId); + let ninja = kernel.get(warriorId); expect(ninja.name).eql(ninjaName); expect(resolverResolveStub.calledOnce).eql(true); expect(plannerCreateContextStub.calledOnce).eql(true); @@ -260,19 +259,19 @@ describe("Kernel", () => { it("Should NOT be able to get ambiguous match", () => { - interface IWarrior {} + interface Warrior {} @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} @injectable() - class Samurai implements IWarrior {} + class Samurai implements Warrior {} - let warriorId = "IWarrior"; + let warriorId = "Warrior"; let kernel = new Kernel(); - kernel.bind(warriorId).to(Ninja); - kernel.bind(warriorId).to(Samurai); + kernel.bind(warriorId).to(Ninja); + kernel.bind(warriorId).to(Samurai); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; @@ -281,21 +280,21 @@ describe("Kernel", () => { expect(dictionary[0].serviceIdentifier).eql(warriorId); expect(dictionary[0].value.length).eql(2); - let throwFunction = () => { kernel.get(warriorId); }; + let throwFunction = () => { kernel.get(warriorId); }; expect(throwFunction).to.throw(`${ERROR_MSGS.AMBIGUOUS_MATCH} ${warriorId}`); }); it("Should NOT be able to getAll of an unregistered services", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaId = "INinja"; + class Ninja implements Ninja {} + let ninjaId = "Ninja"; let kernel = new Kernel(); - let throwFunction = () => { kernel.getAll(ninjaId); }; + let throwFunction = () => { kernel.getAll(ninjaId); }; expect(throwFunction).to.throw(`${ERROR_MSGS.NOT_REGISTERED} ${ninjaId}`); @@ -303,12 +302,12 @@ describe("Kernel", () => { it("Should be able to getAll of a registered and not ambiguous service", () => { - interface INinja { + interface Warrior { name: string; } @injectable() - class Ninja implements INinja { + class Ninja implements Warrior { public name: string; @@ -317,18 +316,18 @@ describe("Kernel", () => { } } - let ninjaId = "INinja"; + let warriorId = "Warrior"; let ninjaName = "Ryu Hayabusa"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(warriorId).to(Ninja); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; // pre conditions expect(dictionary.length).eql(1); - expect(dictionary[0].serviceIdentifier).eql(ninjaId); + expect(dictionary[0].serviceIdentifier).eql(warriorId); expect(dictionary[0].value.length).eql(1); // mock planner and resolver @@ -342,7 +341,7 @@ describe("Kernel", () => { let plannerCreatePlanStub = sandbox.stub(planner, "createPlan").returns(null); let resolverResolveStub = sandbox.stub(resolver, "resolve").returns(new Ninja(ninjaName)); - let ninjas = kernel.getAll(ninjaId); + let ninjas = kernel.getAll(warriorId); expect(ninjas.length).eql(1); expect(ninjas[0].name).eql(ninjaName); expect(resolverResolveStub.calledOnce).eql(true); @@ -353,12 +352,12 @@ describe("Kernel", () => { it("Should be able to getAll of an ambiguous service", () => { - interface IWarrior { + interface Warrior { name: string; } @injectable() - class Ninja implements IWarrior { + class Ninja implements Warrior { public name: string; @@ -368,7 +367,7 @@ describe("Kernel", () => { } @injectable() - class Samurai implements IWarrior { + class Samurai implements Warrior { public name: string; @@ -377,13 +376,13 @@ describe("Kernel", () => { } } - let warriorId = "IWarrior"; + let warriorId = "Warrior"; let ninjaName = "Ryu Hayabusa"; let samuraiName = "Katsumoto"; let kernel = new Kernel(); - kernel.bind(warriorId).to(Ninja); - kernel.bind(warriorId).to(Samurai); + kernel.bind(warriorId).to(Ninja); + kernel.bind(warriorId).to(Samurai); let _kernel: any = kernel; let dictionary = _kernel._bindingDictionary._dictionary; @@ -407,7 +406,7 @@ describe("Kernel", () => { resolverResolveStub.onCall(0).returns(new Ninja(ninjaName)); resolverResolveStub.onCall(1).returns(new Samurai(samuraiName)); - let warriors = kernel.getAll(warriorId); + let warriors = kernel.getAll(warriorId); expect(warriors.length).eql(2); expect(warriors[0].name).eql(ninjaName); expect(warriors[1].name).eql(samuraiName); @@ -418,17 +417,17 @@ describe("Kernel", () => { }); it("Should be able to get a string literal identifier as a string", () => { - let IKatana = "IKatana"; + let Katana = "Katana"; let kernel = new Kernel(); - let KatanaStr = kernel.getServiceIdentifierAsString(IKatana); - expect(KatanaStr).to.eql("IKatana"); + let KatanaStr = kernel.getServiceIdentifierAsString(Katana); + expect(KatanaStr).to.eql("Katana"); }); it("Should be able to get a symbol identifier as a string", () => { - let IKatanaSymbol = Symbol("IKatana"); + let KatanaSymbol = Symbol("Katana"); let kernel = new Kernel(); - let KatanaStr = kernel.getServiceIdentifierAsString(IKatanaSymbol); - expect(KatanaStr).to.eql("Symbol(IKatana)"); + let KatanaStr = kernel.getServiceIdentifierAsString(KatanaSymbol); + expect(KatanaStr).to.eql("Symbol(Katana)"); }); it("Should be able to get a class identifier as a string", () => { @@ -440,18 +439,18 @@ describe("Kernel", () => { it("Should be able to snapshot and restore kernel", () => { - interface IWarrior { + interface Warrior { } @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} @injectable() - class Samurai implements IWarrior {} + class Samurai implements Warrior {} let kernel = new Kernel(); - kernel.bind(Ninja).to(Ninja); - kernel.bind(Samurai).to(Samurai); + kernel.bind(Ninja).to(Ninja); + kernel.bind(Samurai).to(Samurai); expect(kernel.get(Samurai)).to.be.instanceOf(Samurai); expect(kernel.get(Ninja)).to.be.instanceOf(Ninja); @@ -465,7 +464,7 @@ describe("Kernel", () => { kernel.snapshot(); // snapshot kernel = v2 expect(() => kernel.get(Ninja )).to.throw(); - kernel.bind(Ninja).to(Ninja); + kernel.bind(Ninja).to(Ninja); expect(kernel.get(Samurai)).to.be.instanceOf(Samurai); expect(kernel.get(Ninja)).to.be.instanceOf(Ninja); @@ -482,28 +481,28 @@ describe("Kernel", () => { it("Should be able to check is there are bindings available for a given identifier", () => { - interface IWarrior {} - let warriorId = "IWarrior"; - let warriorSymbol = Symbol("IWarrior"); + interface Warrior {} + let warriorId = "Warrior"; + let warriorSymbol = Symbol("Warrior"); @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} let kernel = new Kernel(); - kernel.bind(Ninja).to(Ninja); - kernel.bind(warriorId).to(Ninja); - kernel.bind(warriorSymbol).to(Ninja); + kernel.bind(Ninja).to(Ninja); + kernel.bind(warriorId).to(Ninja); + kernel.bind(warriorSymbol).to(Ninja); expect(kernel.isBound(Ninja)).eql(true); expect(kernel.isBound(warriorId)).eql(true); expect(kernel.isBound(warriorSymbol)).eql(true); - interface IKatana {} - let katanaId = "IKatana"; - let katanaSymbol = Symbol("IKatana"); + interface Katana {} + let katanaId = "Katana"; + let katanaSymbol = Symbol("Katana"); @injectable() - class Katana implements IKatana {} + class Katana implements Katana {} expect(kernel.isBound(Katana)).eql(false); expect(kernel.isBound(katanaId)).eql(false); diff --git a/test/kernel/kernel_module.test.ts b/test/kernel/kernel_module.test.ts index c9d5622fc..5af2440c0 100644 --- a/test/kernel/kernel_module.test.ts +++ b/test/kernel/kernel_module.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import KernelModule from "../../src/kernel/kernel_module"; @@ -7,7 +6,7 @@ describe("KernelModule", () => { it("Should throw when invoking get, remove or hasKey with a null key", () => { - let registry = (bind: IBind) => { /* do nothing */ }; + let registry = (bind: interfaces.Bind) => { /* do nothing */ }; let warriors = new KernelModule(registry); expect(warriors.guid.length).eql(36); diff --git a/test/kernel/key_value_pair.test.ts b/test/kernel/key_value_pair.test.ts index a42a86e56..afe47b9d3 100644 --- a/test/kernel/key_value_pair.test.ts +++ b/test/kernel/key_value_pair.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import KeyValuePair from "../../src/kernel/key_value_pair"; diff --git a/test/kernel/lookup.test.ts b/test/kernel/lookup.test.ts index 82f947bca..b8d6ba705 100644 --- a/test/kernel/lookup.test.ts +++ b/test/kernel/lookup.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import Lookup from "../../src/kernel/lookup"; import * as ERROR_MSGS from "../../src/constants/error_msgs"; @@ -50,7 +49,7 @@ describe("Lookup", () => { it("Should be clonable", () => { - let lookup = new Lookup>(); + let lookup = new Lookup>(); let key1 = Symbol("TEST_KEY"); class Warrior { @@ -78,36 +77,36 @@ describe("Lookup", () => { let moduleId1 = "moduleId1"; let moduleId2 = "moduleId2"; - let warriorId = "IWarrior"; - let weaponId = "IWeapon"; + let warriorId = "Warrior"; + let weaponId = "Weapon"; let getLookup = () => { - interface IWarrior {} + interface Warrior {} - class Ninja implements IWarrior {} + class Ninja implements Warrior {} let ninjaBinding = new Binding(warriorId); ninjaBinding.implementationType = Ninja; ninjaBinding.moduleId = moduleId1; - class Samurai implements IWarrior {} + class Samurai implements Warrior {} let samuraiBinding = new Binding(warriorId); samuraiBinding.implementationType = Samurai; samuraiBinding.moduleId = moduleId2; - interface IWeapon {} + interface Weapon {} - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} let shurikenBinding = new Binding(weaponId); shurikenBinding.implementationType = Shuriken; shurikenBinding.moduleId = moduleId1; - class Katana implements IWeapon {} + class Katana implements Weapon {} let katanaBinding = new Binding(weaponId); katanaBinding.implementationType = Katana; katanaBinding.moduleId = moduleId2; - let lookup = new Lookup>(); + let lookup = new Lookup>(); lookup.add(warriorId, ninjaBinding); lookup.add(warriorId, samuraiBinding); lookup.add(weaponId, shurikenBinding); diff --git a/test/middleware/middleware.test.ts b/test/middleware/middleware.test.ts index 6b7840919..777f65d5f 100644 --- a/test/middleware/middleware.test.ts +++ b/test/middleware/middleware.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Kernel from "../../src/kernel/kernel"; @@ -23,8 +22,8 @@ describe("Middleware", () => { let log: string[] = []; - function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware1(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware1: ${args.serviceIdentifier}`); return planAndResolve(args); }; @@ -38,24 +37,24 @@ describe("Middleware", () => { it("Should support middleware", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} let kernel = new Kernel(); let log: string[] = []; - function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware1(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware1: ${args.serviceIdentifier}`); return planAndResolve(args); }; } - function middleware2(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware2(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware2: ${args.serviceIdentifier}`); return planAndResolve(args); }; @@ -64,37 +63,37 @@ describe("Middleware", () => { // two middlewares applied at one single point in time kernel.applyMiddleware(middleware1, middleware2); - kernel.bind("INinja").to(Ninja); + kernel.bind("Ninja").to(Ninja); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja instanceof Ninja).eql(true); expect(log.length).eql(2); - expect(log[0]).eql(`Middleware2: INinja`); - expect(log[1]).eql(`Middleware1: INinja`); + expect(log[0]).eql(`Middleware2: Ninja`); + expect(log[1]).eql(`Middleware1: Ninja`); }); it("Should allow applyMiddleware at mutiple points in time", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} let kernel = new Kernel(); let log: string[] = []; - function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware1(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware1: ${args.serviceIdentifier}`); return planAndResolve(args); }; } - function middleware2(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware2(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware2: ${args.serviceIdentifier}`); return planAndResolve(args); }; @@ -102,67 +101,67 @@ describe("Middleware", () => { kernel.applyMiddleware(middleware1); // one point in time kernel.applyMiddleware(middleware2); // another point in time - kernel.bind("INinja").to(Ninja); + kernel.bind("Ninja").to(Ninja); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja instanceof Ninja).eql(true); expect(log.length).eql(2); - expect(log[0]).eql(`Middleware2: INinja`); - expect(log[1]).eql(`Middleware1: INinja`); + expect(log[0]).eql(`Middleware2: Ninja`); + expect(log[1]).eql(`Middleware1: Ninja`); }); it("Should use middleware", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} let kernel = new Kernel(); let log: string[] = []; - function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware1(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware1: ${args.serviceIdentifier}`); return planAndResolve(args); }; } - function middleware2(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware2(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { log.push(`Middleware2: ${args.serviceIdentifier}`); return planAndResolve(args); }; } kernel.applyMiddleware(middleware1, middleware2); - kernel.bind("INinja").to(Ninja); + kernel.bind("Ninja").to(Ninja); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja instanceof Ninja).eql(true); expect(log.length).eql(2); - expect(log[0]).eql(`Middleware2: INinja`); - expect(log[1]).eql(`Middleware1: INinja`); + expect(log[0]).eql(`Middleware2: Ninja`); + expect(log[1]).eql(`Middleware1: Ninja`); }); it("Should be able to use middleware to catch errors during pre-planning phase", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} let kernel = new Kernel(); let log: string[] = []; - function middleware(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { try { return planAndResolve(args); } catch (e) { @@ -173,7 +172,7 @@ describe("Middleware", () => { } kernel.applyMiddleware(middleware); - kernel.bind("INinja").to(Ninja); + kernel.bind("Ninja").to(Ninja); kernel.get("SOME_NOT_REGISTERED_ID"); expect(log.length).eql(1); expect(log[0]).eql(`No bindings found for serviceIdentifier: SOME_NOT_REGISTERED_ID`); @@ -182,20 +181,20 @@ describe("Middleware", () => { it("Should be able to use middleware to catch errors during planning phase", () => { - interface IWarrior {} + interface Warrior {} @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} @injectable() - class Samurai implements IWarrior {} + class Samurai implements Warrior {} let kernel = new Kernel(); let log: string[] = []; - function middleware(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { try { return planAndResolve(args); } catch (e) { @@ -206,31 +205,31 @@ describe("Middleware", () => { } kernel.applyMiddleware(middleware); - kernel.bind("IWarrior").to(Ninja); - kernel.bind("IWarrior").to(Samurai); + kernel.bind("Warrior").to(Ninja); + kernel.bind("Warrior").to(Samurai); - kernel.get("IWarrior"); + kernel.get("Warrior"); expect(log.length).eql(1); - expect(log[0]).eql(`Ambiguous match found for serviceIdentifier: IWarrior`); + expect(log[0]).eql(`Ambiguous match found for serviceIdentifier: Warrior`); }); it("Should be able to use middleware to catch errors during resolution phase", () => { - interface IWarrior {} + interface Warrior {} @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} @injectable() - class Samurai implements IWarrior {} + class Samurai implements Warrior {} let kernel = new Kernel(); let log: string[] = []; - function middleware(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { try { return planAndResolve(args); } catch (e) { @@ -241,28 +240,28 @@ describe("Middleware", () => { } kernel.applyMiddleware(middleware); - kernel.bind("IWarrior"); // Invalid binding missing BindingToSyntax + kernel.bind("Warrior"); // Invalid binding missing BindingToSyntax - kernel.get("IWarrior"); + kernel.get("Warrior"); expect(log.length).eql(1); - expect(log[0]).eql(`Invalid binding type: IWarrior`); + expect(log[0]).eql(`Invalid binding type: Warrior`); }); it("Should help users to identify problems with middleware", () => { - interface IWarrior {} + interface Warrior {} @injectable() - class Ninja implements IWarrior {} + class Ninja implements Warrior {} @injectable() - class Samurai implements IWarrior {} + class Samurai implements Warrior {} let kernel = new Kernel(); - function middleware(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { try { return planAndResolve(args); } catch (e) { @@ -279,19 +278,19 @@ describe("Middleware", () => { it("Should allow users to intercep a resolution context", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} + class Ninja implements Ninja {} let kernel = new Kernel(); let log: string[] = []; - function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware1(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { let nextContextInterceptor = args.contextInterceptor; - args.contextInterceptor = (context: IContext) => { + args.contextInterceptor = (context: interfaces.Context) => { log.push(`contextInterceptor1: ${args.serviceIdentifier}`); return nextContextInterceptor(context); }; @@ -299,10 +298,10 @@ describe("Middleware", () => { }; } - function middleware2(planAndResolve: PlanAndResolve): PlanAndResolve { - return (args: PlanAndResolveArgs) => { + function middleware2(planAndResolve: interfaces.PlanAndResolve): interfaces.PlanAndResolve { + return (args: interfaces.PlanAndResolveArgs) => { let nextContextInterceptor = args.contextInterceptor; - args.contextInterceptor = (context: IContext) => { + args.contextInterceptor = (context: interfaces.Context) => { log.push(`contextInterceptor2: ${args.serviceIdentifier}`); return nextContextInterceptor(context); }; @@ -311,14 +310,14 @@ describe("Middleware", () => { } kernel.applyMiddleware(middleware1, middleware2); - kernel.bind("INinja").to(Ninja); + kernel.bind("Ninja").to(Ninja); - let ninja = kernel.get("INinja"); + let ninja = kernel.get("Ninja"); expect(ninja instanceof Ninja).eql(true); expect(log.length).eql(2); - expect(log[0]).eql(`contextInterceptor1: INinja`); - expect(log[1]).eql(`contextInterceptor2: INinja`); + expect(log[0]).eql(`contextInterceptor1: Ninja`); + expect(log[1]).eql(`contextInterceptor2: Ninja`); }); diff --git a/test/planning/context.test.ts b/test/planning/context.test.ts index 9ce2a2732..c3892098f 100644 --- a/test/planning/context.test.ts +++ b/test/planning/context.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Kernel from "../../src/kernel/kernel"; import Context from "../../src/planning/context"; @@ -28,7 +26,7 @@ describe("Context", () => { let context = new Context(kernel); let ninjaRequest = new Request( - "INinja", + "Ninja", context, null, null @@ -37,7 +35,7 @@ describe("Context", () => { let plan = new Plan(context, ninjaRequest); context.addPlan(plan); - expect(context.plan.rootRequest.serviceIdentifier).eql("INinja"); + expect(context.plan.rootRequest.serviceIdentifier).eql("Ninja"); }); }); diff --git a/test/planning/metadata.test.ts b/test/planning/metadata.test.ts index 810c0a841..eecb5ff8f 100644 --- a/test/planning/metadata.test.ts +++ b/test/planning/metadata.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Metadata from "../../src/planning/metadata"; diff --git a/test/planning/plan.test.ts b/test/planning/plan.test.ts index 839081ec3..3e414a9df 100644 --- a/test/planning/plan.test.ts +++ b/test/planning/plan.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Plan from "../../src/planning/plan"; import Request from "../../src/planning/request"; diff --git a/test/planning/planner.test.ts b/test/planning/planner.test.ts index 4487f0558..020edbbd9 100644 --- a/test/planning/planner.test.ts +++ b/test/planning/planner.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Planner from "../../src/planning/planner"; @@ -40,63 +39,63 @@ describe("Planner", () => { it("Should be able to create a basic plan", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Katana { + public handler: KatanaHandler; + public blade: KatanaBlade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("KatanaHandler") @targetName("handler") handler: KatanaHandler, + @inject("KatanaBlade") @targetName("blade") blade: KatanaBlade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Ninja { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaId = "Katana"; + let katanaHandlerId = "KatanaHandler"; + let katanaBladeId = "KatanaBlade"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).to(Katana); + kernel.bind(katanaBladeId).to(KatanaBlade); + kernel.bind(katanaHandlerId).to(KatanaHandler); let planner = new Planner(); let context = planner.createContext(kernel); @@ -136,7 +135,7 @@ describe("Planner", () => { expect(actualNinjaRequest.childRequests.length) .eql(ninjaRequest.childRequests.length); - // IKatana + // Katana expect(actualKatanaRequest.serviceIdentifier) .eql(katanaRequest.serviceIdentifier); @@ -152,7 +151,7 @@ describe("Planner", () => { expect(actualKatanaRequest.childRequests.length) .eql(katanaRequest.childRequests.length); - // IKatanaHandler + // KatanaHandler expect(actualKatanaHandlerRequest.serviceIdentifier) .eql(katanaHandlerRequest.serviceIdentifier); @@ -165,7 +164,7 @@ describe("Planner", () => { expect(actualKatanaHandlerRequest.target.serviceIdentifier) .eql(katanaHandlerRequest.target.serviceIdentifier); - // IKatanaBalde + // KatanaBalde expect(actualKatanaBladeRequest.serviceIdentifier) .eql(katanaBladeRequest.serviceIdentifier); @@ -178,7 +177,7 @@ describe("Planner", () => { expect(actualKatanaBladeRequest.target.serviceIdentifier) .eql(katanaBladeRequest.target.serviceIdentifier); - // IShuriken + // Shuriken expect(actualShurikenRequest.serviceIdentifier) .eql(shurikenRequest.serviceIdentifier); @@ -195,57 +194,57 @@ describe("Planner", () => { it("Should throw when circular dependencies found", () => { - interface IA {} - interface IB {} - interface IC {} - interface ID {} + interface A {} + interface B {} + interface C {} + interface D {} @injectable() - class D implements IC { - public a: IA; + class D implements D { + public a: A; public constructor( - @inject("IA") a: IA + @inject("A") a: A ) { // circular dependency this.a = a; } } @injectable() - class C implements IC { - public d: ID; + class C implements C { + public d: D; public constructor( - @inject("ID") d: ID + @inject("D") d: D ) { this.d = d; } } @injectable() - class B implements IB {} + class B implements B {} @injectable() - class A implements IA { - public b: IB; - public c: IC; + class A implements A { + public b: B; + public c: C; public constructor( - @inject("IB") b: IB, - @inject("IC") c: IC + @inject("B") b: B, + @inject("C") c: C ) { this.b = b; this.c = c; } } - let aId = "IA"; - let bId = "IB"; - let cId = "IC"; - let dId = "ID"; + let aId = "A"; + let bId = "B"; + let cId = "C"; + let dId = "D"; let kernel = new Kernel(); - kernel.bind(aId).to(A); - kernel.bind(bId).to(B); - kernel.bind(cId).to(C); - kernel.bind(dId).to(D); + kernel.bind(aId).to(A); + kernel.bind(bId).to(B); + kernel.bind(cId).to(C); + kernel.bind(dId).to(D); let throwErroFunction = () => { kernel.get(aId); @@ -257,67 +256,67 @@ describe("Planner", () => { it("Should only plan sub-dependencies when binding type is BindingType.Instance", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Katana { + public handler: KatanaHandler; + public blade: KatanaBlade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("KatanaHandler") @targetName("handler") handler: KatanaHandler, + @inject("KatanaBlade") @targetName("blade") blade: KatanaBlade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katanaFactory: IFactory; - public shuriken: IShuriken; + class Ninja implements Ninja { + public katanaFactory: interfaces.Factory; + public shuriken: Shuriken; public constructor( - @inject("IFactory") @targetName("katanaFactory") katanaFactory: IFactory, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Factory") @targetName("katanaFactory") katanaFactory: interfaces.Factory, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katanaFactory = katanaFactory; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; - let katanaFactoryId = "IFactory"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaId = "Katana"; + let katanaHandlerId = "KatanaHandler"; + let katanaBladeId = "KatanaBlade"; + let katanaFactoryId = "Factory"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaBladeId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); - kernel.bind>(katanaFactoryId).toFactory((context) => { + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaBladeId).to(Katana); + kernel.bind(katanaBladeId).to(KatanaBlade); + kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind>(katanaFactoryId).toFactory((context: interfaces.Context) => { return () => { - return context.kernel.get(katanaId); + return context.kernel.get(katanaId); }; }); @@ -338,35 +337,35 @@ describe("Planner", () => { it("Should generate plans with multi-injections", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon {} + class Katana implements Weapon {} @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @multiInject("IWeapon") @targetName("weapons") weapons: IWeapon[] + @multiInject("Weapon") @targetName("weapons") weapons: Weapon[] ) { this.katana = weapons[0]; this.shuriken = weapons[1]; } } - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Shuriken); - kernel.bind(weaponId).to(Katana); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(weaponId).to(Shuriken); + kernel.bind(weaponId).to(Katana); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -378,31 +377,31 @@ describe("Planner", () => { expect(actualPlan.rootRequest.serviceIdentifier).eql(ninjaId); expect(actualPlan.rootRequest.target).eql(null); - // root request should only have one child request with target weapons/IWeapon[] - expect(actualPlan.rootRequest.childRequests[0].serviceIdentifier).eql("IWeapon"); + // root request should only have one child request with target weapons/Weapon[] + expect(actualPlan.rootRequest.childRequests[0].serviceIdentifier).eql("Weapon"); expect(actualPlan.rootRequest.childRequests[1]).eql(undefined); expect(actualPlan.rootRequest.childRequests[0].target.name.value()).eql("weapons"); - expect(actualPlan.rootRequest.childRequests[0].target.serviceIdentifier).eql("IWeapon"); + expect(actualPlan.rootRequest.childRequests[0].target.serviceIdentifier).eql("Weapon"); expect(actualPlan.rootRequest.childRequests[0].target.isArray()).eql(true); - // child request should have two child requests with targets weapons/IWeapon[] but bindings Katana and Shuriken + // child request should have two child requests with targets weapons/Weapon[] but bindings Katana and Shuriken expect(actualPlan.rootRequest.childRequests[0].childRequests.length).eql(2); expect(actualPlan.rootRequest.childRequests[0].childRequests[0].serviceIdentifier).eql(weaponId); expect(actualPlan.rootRequest.childRequests[0].childRequests[0].target.name.value()).eql("weapons"); - expect(actualPlan.rootRequest.childRequests[0].childRequests[0].target.serviceIdentifier).eql("IWeapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[0].target.serviceIdentifier).eql("Weapon"); expect(actualPlan.rootRequest.childRequests[0].childRequests[0].target.isArray()).eql(true); - expect(actualPlan.rootRequest.childRequests[0].childRequests[0].serviceIdentifier).eql("IWeapon"); - expect(actualPlan.rootRequest.childRequests[0].childRequests[0].bindings[0].serviceIdentifier).eql("IWeapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[0].serviceIdentifier).eql("Weapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[0].bindings[0].serviceIdentifier).eql("Weapon"); let shurikenImplementationType: any = actualPlan.rootRequest.childRequests[0].childRequests[0].bindings[0].implementationType; expect(shurikenImplementationType.name).eql("Shuriken"); expect(actualPlan.rootRequest.childRequests[0].childRequests[1].serviceIdentifier).eql(weaponId); expect(actualPlan.rootRequest.childRequests[0].childRequests[1].target.name.value()).eql("weapons"); - expect(actualPlan.rootRequest.childRequests[0].childRequests[1].target.serviceIdentifier).eql("IWeapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[1].target.serviceIdentifier).eql("Weapon"); expect(actualPlan.rootRequest.childRequests[0].childRequests[1].target.isArray()).eql(true); - expect(actualPlan.rootRequest.childRequests[0].childRequests[1].serviceIdentifier).eql("IWeapon"); - expect(actualPlan.rootRequest.childRequests[0].childRequests[1].bindings[0].serviceIdentifier).eql("IWeapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[1].serviceIdentifier).eql("Weapon"); + expect(actualPlan.rootRequest.childRequests[0].childRequests[1].bindings[0].serviceIdentifier).eql("Weapon"); let katanaImplementationType: any = actualPlan.rootRequest.childRequests[0].childRequests[1].bindings[0].implementationType; expect(katanaImplementationType.name).eql("Katana"); @@ -410,35 +409,35 @@ describe("Planner", () => { it("Should throw when no matching bindings are found", () => { - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { } + class Katana implements Katana { } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Ninja { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -446,47 +445,47 @@ describe("Planner", () => { let context = planner.createContext(kernel); let throwFunction = () => { planner.createPlan(context, ninjaBinding, null); }; - expect(throwFunction).to.throw(`${ERROR_MSGS.NOT_REGISTERED} IKatana`); + expect(throwFunction).to.throw(`${ERROR_MSGS.NOT_REGISTERED} Katana`); }); it("Should throw when an ambiguous match is found", () => { - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { } + class Katana implements Katana { } @injectable() - class SharpKatana implements IKatana { } + class SharpKatana implements Katana { } - interface IShuriken {} - class Shuriken implements IShuriken {} + interface Shuriken {} + class Shuriken implements Shuriken {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Ninja { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let katanaId = "IKatana"; - let shurikenId = "IShuriken"; + let ninjaId = "Ninja"; + let katanaId = "Katana"; + let shurikenId = "Shuriken"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaId).to(SharpKatana); - kernel.bind(shurikenId).to(Shuriken); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(katanaId).to(Katana); + kernel.bind(katanaId).to(SharpKatana); + kernel.bind(shurikenId).to(Shuriken); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -494,32 +493,32 @@ describe("Planner", () => { let context = planner.createContext(kernel); let throwFunction = () => { planner.createPlan(context, ninjaBinding, null); }; - expect(throwFunction).to.throw(`${ERROR_MSGS.AMBIGUOUS_MATCH} IKatana`); + expect(throwFunction).to.throw(`${ERROR_MSGS.AMBIGUOUS_MATCH} Katana`); }); it("Should apply constrains when an ambiguous match is found", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja {} + interface Ninja {} - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject(weaponId) @targetName("katana") @tagged("canThrow", false) katana: IWeapon, - @inject(weaponId) @targetName("shuriken") @tagged("canThrow", true) shuriken: IWeapon + @inject(weaponId) @targetName("katana") @tagged("canThrow", false) katana: Weapon, + @inject(weaponId) @targetName("shuriken") @tagged("canThrow", true) shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -527,9 +526,9 @@ describe("Planner", () => { } let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); - kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); + kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -557,15 +556,15 @@ describe("Planner", () => { it("Should be throw when a class has a missing @injectable annotation", () => { - interface IWeapon {} + interface Weapon {} - class Katana implements IWeapon {} + class Katana implements Weapon {} let kernel = new Kernel(); - kernel.bind("IWeapon").to(Katana); + kernel.bind("Weapon").to(Katana); let _kernel: any = kernel; - let ninjaBinding = _kernel._bindingDictionary.get("IWeapon")[0]; + let ninjaBinding = _kernel._bindingDictionary.get("Weapon")[0]; let planner = new Planner(); let context = planner.createContext(kernel); @@ -577,33 +576,33 @@ describe("Planner", () => { }); - it("Should be throw when an interface has a missing @injectable annotation", () => { + it("Should throw when an class has a missing @inject annotation", () => { - interface IKatana {} + interface Sword {} @injectable() - class Katana implements IKatana { } + class Katana implements Sword { } - interface INinja {} + interface Warrior {} @injectable() - class Ninja implements INinja { + class Ninja implements Warrior { - public katana: IKatana; + public katana: Katana; public constructor( - katana: IKatana + katana: Sword ) { this.katana = katana; } } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IKatana").to(Katana); + kernel.bind("Warrior").to(Ninja); + kernel.bind("Sword").to(Katana); let _kernel: any = kernel; - let ninjaBinding = _kernel._bindingDictionary.get("INinja")[0]; + let ninjaBinding = _kernel._bindingDictionary.get("Warrior")[0]; let planner = new Planner(); let context = planner.createContext(kernel); @@ -615,34 +614,34 @@ describe("Planner", () => { }); - it("Should be throw when a function has a missing @injectable annotation", () => { + it("Should throw when a function has a missing @injectable annotation", () => { - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { } + class Katana implements Katana { } - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { + class Ninja implements Ninja { - public katana: IKatana; + public katana: Katana; public constructor( - katanaFactory: () => IKatana + katanaFactory: () => Katana ) { this.katana = katanaFactory(); } } let kernel = new Kernel(); - kernel.bind("INinja").to(Ninja); - kernel.bind("IKatana").to(Katana); - kernel.bind("IFactory").to(Katana); + kernel.bind("Ninja").to(Ninja); + kernel.bind("Katana").to(Katana); + kernel.bind("Factory").to(Katana); let _kernel: any = kernel; - let ninjaBinding = _kernel._bindingDictionary.get("INinja")[0]; + let ninjaBinding = _kernel._bindingDictionary.get("Ninja")[0]; let planner = new Planner(); let context = planner.createContext(kernel); diff --git a/test/planning/queryable_string.test.ts b/test/planning/queryable_string.test.ts index ecd0508ca..5ac2d8c2e 100644 --- a/test/planning/queryable_string.test.ts +++ b/test/planning/queryable_string.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import QueryableString from "../../src/planning/queryable_string"; diff --git a/test/planning/request.test.ts b/test/planning/request.test.ts index 69a965a76..3a07fdf89 100644 --- a/test/planning/request.test.ts +++ b/test/planning/request.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Request from "../../src/planning/request"; import Context from "../../src/planning/context"; @@ -10,11 +8,11 @@ import injectable from "../../src/annotation/injectable"; describe("Request", () => { let identifiers = { - IKatana: "IKatana", - IKatanaBlade: "IKatanaBlade", - IKatanaHandler: "IKatanaHandler", - INinja: "INinja", - IShuriken: "IShuriken", + Katana: "Katana", + KatanaBlade: "KatanaBlade", + KatanaHandler: "KatanaHandler", + Ninja: "Ninja", + Shuriken: "Shuriken", }; it("Should set its own properties correctly", () => { @@ -23,7 +21,7 @@ describe("Request", () => { let context = new Context(kernel); let request1 = new Request( - identifiers.INinja, + identifiers.Ninja, context, null, null, @@ -31,14 +29,14 @@ describe("Request", () => { ); let request2 = new Request( - identifiers.INinja, + identifiers.Ninja, context, null, [], null ); - expect(request1.serviceIdentifier).eql(identifiers.INinja); + expect(request1.serviceIdentifier).eql(identifiers.Ninja); expect(Array.isArray(request1.bindings)).eql(true); expect(Array.isArray(request2.bindings)).eql(true); expect(request1.guid.length).eql(36); @@ -49,39 +47,39 @@ describe("Request", () => { it("Should be able to add a child request", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; - public constructor(handler: IKatanaHandler, blade: IKatanaBlade) { + class Katana implements Katana { + public handler: KatanaHandler; + public blade: KatanaBlade; + public constructor(handler: KatanaHandler, blade: KatanaBlade) { // DO NOTHING } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; - public constructor(katana: IKatana, shuriken: IShuriken) { + class Ninja implements Ninja { + public katana: Katana; + public shuriken: Shuriken; + public constructor(katana: Katana, shuriken: Shuriken) { // DO NOTHING } } @@ -90,7 +88,7 @@ describe("Request", () => { let context = new Context(kernel); let ninjaRequest = new Request( - identifiers.INinja, + identifiers.Ninja, context, null, null, @@ -98,17 +96,17 @@ describe("Request", () => { ); ninjaRequest.addChildRequest( - identifiers.IKatana, + identifiers.Katana, null, - new Target("katana", identifiers.IKatana)); + new Target("katana", identifiers.Katana)); let katanaRequest = ninjaRequest.childRequests[0]; - expect(katanaRequest.serviceIdentifier).eql(identifiers.IKatana); - expect(katanaRequest.parentRequest.serviceIdentifier).eql(identifiers.INinja); + expect(katanaRequest.serviceIdentifier).eql(identifiers.Katana); + expect(katanaRequest.parentRequest.serviceIdentifier).eql(identifiers.Ninja); expect(katanaRequest.childRequests.length).eql(0); expect(katanaRequest.target.name.value()).eql("katana"); - expect(katanaRequest.target.serviceIdentifier).eql(identifiers.IKatana); + expect(katanaRequest.target.serviceIdentifier).eql(identifiers.Katana); }); }); diff --git a/test/planning/target.test.ts b/test/planning/target.test.ts index 4f96d6c9f..320283306 100644 --- a/test/planning/target.test.ts +++ b/test/planning/target.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Target from "../../src/planning/target"; import Metadata from "../../src/planning/metadata"; @@ -8,16 +6,16 @@ import * as METADATA_KEY from "../../src/constants/metadata_keys"; describe("Target", () => { it("Should be able to create instances of untagged tagets", () => { - let target = new Target("katana", "IKatana"); - expect(target.serviceIdentifier).to.be.eql("IKatana"); + let target = new Target("katana", "Katana"); + expect(target.serviceIdentifier).to.be.eql("Katana"); expect(target.name.value()).to.be.eql("katana"); expect(Array.isArray(target.metadata)).to.be.eql(true); expect(target.metadata.length).to.be.eql(0); }); it("Should be able to create instances of named tagets", () => { - let target = new Target("katana", "IKatana", "primary"); - expect(target.serviceIdentifier).to.be.eql("IKatana"); + let target = new Target("katana", "Katana", "primary"); + expect(target.serviceIdentifier).to.be.eql("Katana"); expect(target.name.value()).to.be.eql("katana"); expect(Array.isArray(target.metadata)).to.be.eql(true); expect(target.metadata.length).to.be.eql(1); @@ -26,8 +24,8 @@ describe("Target", () => { }); it("Should be able to create instances of tagged tagets", () => { - let target = new Target("katana", "IKatana", new Metadata("power", 5)); - expect(target.serviceIdentifier).to.be.eql("IKatana"); + let target = new Target("katana", "Katana", new Metadata("power", 5)); + expect(target.serviceIdentifier).to.be.eql("Katana"); expect(target.name.value()).to.be.eql("katana"); expect(Array.isArray(target.metadata)).to.be.eql(true); expect(target.metadata.length).to.be.eql(1); @@ -36,60 +34,60 @@ describe("Target", () => { }); it("Should be able to identify named metadata", () => { - let target1 = new Target("katana", "IKatana", "primary"); + let target1 = new Target("katana", "Katana", "primary"); expect(target1.isNamed()).to.be.eql(true); - let target2 = new Target("katana", "IKatana", new Metadata("power", 5)); + let target2 = new Target("katana", "Katana", new Metadata("power", 5)); expect(target2.isNamed()).to.be.eql(false); }); it("Should be able to identify multi-injections", () => { - let target1 = new Target("katana", "IKatana"); - target1.metadata.push(new Metadata(METADATA_KEY.MULTI_INJECT_TAG, "IKatana")); + let target1 = new Target("katana", "Katana"); + target1.metadata.push(new Metadata(METADATA_KEY.MULTI_INJECT_TAG, "Katana")); expect(target1.isArray()).to.be.eql(true); - let target2 = new Target("katana", "IKatana"); + let target2 = new Target("katana", "Katana"); expect(target2.isArray()).to.be.eql(false); }); it("Should be able to match mutli-inject for a specified service metadata", () => { - let target1 = new Target("katana", "IKatana"); - target1.metadata.push(new Metadata(METADATA_KEY.MULTI_INJECT_TAG, "IKatana")); - target1.metadata.push(new Metadata(METADATA_KEY.INJECT_TAG, "IShuriken")); - expect(target1.matchesArray("IKatana")).to.be.eql(true); - expect(target1.matchesArray("IShuriken")).to.be.eql(false); + let target1 = new Target("katana", "Katana"); + target1.metadata.push(new Metadata(METADATA_KEY.MULTI_INJECT_TAG, "Katana")); + target1.metadata.push(new Metadata(METADATA_KEY.INJECT_TAG, "Shuriken")); + expect(target1.matchesArray("Katana")).to.be.eql(true); + expect(target1.matchesArray("Shuriken")).to.be.eql(false); }); it("Should be able to match named metadata", () => { - let target1 = new Target("katana", "IKatana", "primary"); + let target1 = new Target("katana", "Katana", "primary"); expect(target1.matchesNamedTag("primary")).to.be.eql(true); expect(target1.matchesNamedTag("secondary")).to.be.eql(false); }); it("Should be able to identify tagged metadata", () => { - let target = new Target("katana", "IKatana"); + let target = new Target("katana", "Katana"); expect(target.isTagged()).to.be.eql(false); - let target1 = new Target("katana", "IKatana", new Metadata("power", 5)); + let target1 = new Target("katana", "Katana", new Metadata("power", 5)); expect(target1.isTagged()).to.be.eql(true); - let target2 = new Target("katana", "IKatana", "primary"); + let target2 = new Target("katana", "Katana", "primary"); expect(target2.isTagged()).to.be.eql(false); - let target3 = new Target("katana", "IKatana"); + let target3 = new Target("katana", "Katana"); target3.metadata.push(new Metadata("power", 5), new Metadata("speed", 5)); expect(target3.isTagged()).to.be.eql(true); }); it("Should be able to match tagged metadata", () => { - let target1 = new Target("katana", "IKatana", new Metadata("power", 5)); + let target1 = new Target("katana", "Katana", new Metadata("power", 5)); expect(target1.matchesTag("power")(5)).to.be.eql(true); expect(target1.matchesTag("power")(2)).to.be.eql(false); }); it("Should contain an unique identifier", () => { - let target1 = new Target("katana", "IKatana", new Metadata("power", 5)); - let target2 = new Target("katana", "IKatana", new Metadata("power", 5)); + let target1 = new Target("katana", "Katana", new Metadata("power", 5)); + let target2 = new Target("katana", "Katana", new Metadata("power", 5)); expect(target1.guid.length).eql(36); expect(target2.guid.length).eql(36); expect(target1.guid).not.eql(target2.guid); diff --git a/test/resolution/resolver.test.ts b/test/resolution/resolver.test.ts index 7e6b0ec87..ac1823d0a 100644 --- a/test/resolution/resolver.test.ts +++ b/test/resolution/resolver.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Resolver from "../../src/resolution/resolver"; @@ -32,69 +31,69 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.Instance bindings", () => { - interface IKatanaBlade {} + interface Blade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements Blade {} - interface IKatanaHandler {} + interface Handler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements Handler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: Handler; + public blade: Blade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("Handler") @targetName("handler") handler: Handler, + @inject("Blade") @targetName("blade") blade: Blade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaId = "Katana"; + let katanaHandlerId = "KatanaHandler"; + let katanaBladeId = "KatanaBlade"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).to(Katana); + kernel.bind(katanaBladeId).to(KatanaBlade); + kernel.bind(katanaHandlerId).to(KatanaHandler); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -124,7 +123,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -136,69 +135,69 @@ describe("Resolver", () => { it("Should store singleton type bindings in cache", () => { - interface IKatanaBlade {} + interface Blade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements Blade {} - interface IKatanaHandler {} + interface Handler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements Handler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: Handler; + public blade: Blade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("Handler") @targetName("handler") handler: Handler, + @inject("Blade") @targetName("blade") blade: Blade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaId = "Katana"; + let katanaHandlerId = "KatanaHandler"; + let katanaBladeId = "KatanaBlade"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana).inSingletonScope(); // SINGLETON! - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler).inSingletonScope(); // SINGLETON! + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).to(Katana).inSingletonScope(); // SINGLETON! + kernel.bind(katanaBladeId).to(KatanaBlade); + kernel.bind(katanaHandlerId).to(KatanaHandler).inSingletonScope(); // SINGLETON! let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -230,48 +229,48 @@ describe("Resolver", () => { let resolver = new Resolver(); let createInstanceSpy = sandbox.spy(resolver, "_createInstance"); - expect(_kernel._bindingDictionary.get("IKatana")[0].cache === null).eql(true); + expect(_kernel._bindingDictionary.get("Katana")[0].cache === null).eql(true); expect(createInstanceSpy.callCount).eql(0); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(createInstanceSpy.callCount).eql(2); expect(createInstanceSpy.getCall(0).args[0].name === "Katana").eql(true); expect(createInstanceSpy.getCall(1).args[0].name === "Ninja").eql(true); - let ninja2 = resolver.resolve(context); + let ninja2 = resolver.resolve(context); expect(ninja2 instanceof Ninja).eql(true); expect(createInstanceSpy.callCount).eql(3); expect(createInstanceSpy.getCall(1).args[0].name === "Ninja").eql(true); - expect(_kernel._bindingDictionary.get("IKatana")[0].cache instanceof Katana).eql(true); + expect(_kernel._bindingDictionary.get("Katana")[0].cache instanceof Katana).eql(true); }); it("Should throw when an invalid BindingType is detected", () => { - interface IKatana {} + interface Katana {} @injectable() - class Katana implements IKatana {} + class Katana implements Katana {} - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; @@ -279,10 +278,10 @@ describe("Resolver", () => { } // kernel and bindings - let ninjaId = "INinja"; + let ninjaId = "Ninja"; let kernel = new Kernel(); let _kernel: any = kernel; - kernel.bind(ninjaId); // IMPORTAN! (Invalid binding) + kernel.bind(ninjaId); // IMPORTAN! (Invalid binding) let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; // context and plan @@ -308,59 +307,59 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.ConstantValue bindings", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; - public constructor(handler: IKatanaHandler, blade: IKatanaBlade) { + class Katana implements Sword { + public handler: KatanaHandler; + public blade: KatanaBlade; + public constructor(handler: KatanaHandler, blade: KatanaBlade) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} - class Shuriken implements IShuriken {} + interface Shuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaId = "IKatana"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaId = "Katana"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).toConstantValue(new Katana(new KatanaHandler(), new KatanaBlade())); // IMPORTANT! + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).toConstantValue(new Katana(new KatanaHandler(), new KatanaBlade())); // IMPORTANT! let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -384,7 +383,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -396,12 +395,12 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.DynamicValue bindings", () => { - interface IUseDate { + interface UseDate { doSomething(): Date; } @injectable() - class UseDate implements IUseDate { + class UseDate implements UseDate { public currentDate: Date; public constructor(@inject("Date") currentDate: Date) { this.currentDate = currentDate; @@ -412,81 +411,81 @@ describe("Resolver", () => { } let kernel = new Kernel(); - kernel.bind("IUseDate").to(UseDate); + kernel.bind("UseDate").to(UseDate); kernel.bind("Date").toDynamicValue(() => { return new Date(); }); - let subject1 = kernel.get("IUseDate"); - let subject2 = kernel.get("IUseDate"); + let subject1 = kernel.get("UseDate"); + let subject2 = kernel.get("UseDate"); expect(subject1.doSomething() === subject2.doSomething()).eql(false); kernel.unbind("Date"); kernel.bind("Date").toConstantValue(new Date()); - let subject3 = kernel.get("IUseDate"); - let subject4 = kernel.get("IUseDate"); + let subject3 = kernel.get("UseDate"); + let subject4 = kernel.get("UseDate"); expect(subject3.doSomething() === subject4.doSomething()).eql(true); }); it("Should be able to resolve BindingType.Constructor bindings", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: KatanaHandler; + public blade: KatanaBlade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("KatanaHandler") @targetName("handler") handler: KatanaHandler, + @inject("KatanaBlade") @targetName("blade") blade: KatanaBlade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} - class Shuriken implements IShuriken {} + interface Shuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatana") @targetName("katana") katana: IKatana, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("Katana") @targetName("katana") katana: Katana, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = new Katana(new KatanaHandler(), new KatanaBlade()); // IMPORTANT! this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let newableKatanaId = "INewable"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let newableKatanaId = "Newable"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind>(newableKatanaId).toConstructor(Katana); // IMPORTANT! + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind>(newableKatanaId).toConstructor(Katana); // IMPORTANT! let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -503,7 +502,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -515,84 +514,84 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.Factory bindings", () => { - interface IKatanaBlade {} + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let swordFactoryId = "Factory"; + let katanaId = "Katana"; + let handlerId = "Handler"; + let bladeId = "Blade"; + + interface Blade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements Blade {} - interface IKatanaHandler {} + interface Handler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements Handler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: Handler; + blade: Blade; } - interface IKatanaFactory extends Function { - (): IKatana; + interface SwordFactory extends Function { + (): Sword; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: Handler; + public blade: Blade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject(handlerId) @targetName("handler") handler: Handler, + @inject(bladeId) @targetName("blade") blade: Blade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatanaFactory") @targetName("makeKatana") makeKatana: IKatanaFactory, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject(swordFactoryId) @targetName("makeKatana") makeKatana: SwordFactory, + @inject(shurikenId) @targetName("shuriken") shuriken: Shuriken ) { this.katana = makeKatana(); // IMPORTANT! this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaFactoryId = "IFactory"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; - let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).to(Katana); + kernel.bind(bladeId).to(KatanaBlade); + kernel.bind(handlerId).to(KatanaHandler); - kernel.bind>(katanaFactoryId).toFactory((context: IContext) => { + kernel.bind>(swordFactoryId).toFactory((context: interfaces.Context) => { return () => { - return context.kernel.get(katanaId); + return context.kernel.get(katanaId); }; }); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; - let katanaFactoryBinding = _kernel._bindingDictionary.get(katanaFactoryId)[0]; + let katanaFactoryBinding = _kernel._bindingDictionary.get(swordFactoryId)[0]; let shurikenBinding = _kernel._bindingDictionary.get(shurikenId)[0]; let planner = new Planner(); @@ -600,12 +599,12 @@ describe("Resolver", () => { let ninjaRequest = new Request(ninjaId, context, null, ninjaBinding, null); let plan = new Plan(context, ninjaRequest); - plan.rootRequest.addChildRequest(katanaFactoryId, katanaFactoryBinding, new Target("makeKatana", katanaFactoryId)); + plan.rootRequest.addChildRequest(swordFactoryId, katanaFactoryBinding, new Target("makeKatana", swordFactoryId)); plan.rootRequest.addChildRequest(shurikenId, shurikenBinding, new Target("shuriken", shurikenId)); context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -617,76 +616,76 @@ describe("Resolver", () => { it("Should be able to resolve bindings with auto factory", () => { - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } - interface IKatanaFactory extends Function { - (): IKatana; + interface SwordFactory extends Function { + (): Sword; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: KatanaHandler; + public blade: KatanaBlade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("blade") blade: IKatanaBlade + @inject("KatanaHandler") @targetName("handler") handler: KatanaHandler, + @inject("KatanaBlade") @targetName("blade") blade: KatanaBlade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public shuriken: Shuriken; public constructor( - @inject("IKatanaFactory") @targetName("makeKatana") makeKatana: IKatanaFactory, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject("SwordFactory") @targetName("makeKatana") makeKatana: SwordFactory, + @inject("Shuriken") @targetName("shuriken") shuriken: Shuriken ) { this.katana = makeKatana(); // IMPORTANT! this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaFactoryId = "IFactory"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let katanaFactoryId = "Factory"; + let katanaId = "Katana"; + let katanaHandlerId = "KatanaHandler"; + let katanaBladeId = "KatanaBlade"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(katanaId).to(Katana); + kernel.bind(katanaBladeId).to(KatanaBlade); + kernel.bind(katanaHandlerId).to(KatanaHandler); - kernel.bind>(katanaFactoryId).toAutoFactory(katanaId); + kernel.bind>(katanaFactoryId).toAutoFactory(katanaId); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -703,7 +702,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -715,57 +714,60 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.Provider bindings", (done) => { - interface IKatanaBlade {} + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; + let swordProviderId = "Provider"; + let swordId = "Sword"; + let handlerId = "Handler"; + let bladeId = "Blade"; + + interface Blade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements Blade {} - interface IKatanaHandler {} + interface Handler {} @injectable() - class KatanaHandler implements IKatanaHandler {} - - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; - } + class KatanaHandler implements Handler {} - interface IKatanaFactory extends Function { - (): IKatana; + interface Sword { + handler: Handler; + blade: Blade; } @injectable() - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; + class Katana implements Sword { + public handler: Handler; + public blade: Blade; public constructor( - @inject("IKatanaHandler") @targetName("handler") handler: IKatanaHandler, - @inject("IKatanaBlade") @targetName("handler") blade: IKatanaBlade + @inject(handlerId) @targetName("handler") handler: Handler, + @inject(bladeId) @targetName("handler") blade: Blade ) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} + interface Shuriken {} @injectable() - class Shuriken implements IShuriken {} + class Shuriken implements Shuriken {} - interface INinja { - katana: IKatana; - katanaProvider: IProvider; - shuriken: IShuriken; + interface Warrior { + katana: Katana; + katanaProvider: interfaces.Provider; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { - public katana: IKatana; - public katanaProvider: IProvider; - public shuriken: IShuriken; + class Ninja implements Warrior { + public katana: Katana; + public katanaProvider: interfaces.Provider; + public shuriken: Shuriken; public constructor( - @inject("IProvider") @targetName("katanaProvider") katanaProvider: IProvider, - @inject("IShuriken") @targetName("shuriken") shuriken: IShuriken + @inject(swordProviderId) @targetName("katanaProvider") katanaProvider: interfaces.Provider, + @inject(shurikenId) @targetName("shuriken") shuriken: Shuriken ) { this.katana = null; this.katanaProvider = katanaProvider; @@ -773,32 +775,25 @@ describe("Resolver", () => { } } - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; - let katanaProviderId = "IProvider"; - let katanaId = "IKatana"; - let katanaHandlerId = "IKatanaHandler"; - let katanaBladeId = "IKatanaBlade"; - let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); - kernel.bind(katanaId).to(Katana); - kernel.bind(katanaBladeId).to(KatanaBlade); - kernel.bind(katanaHandlerId).to(KatanaHandler); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); + kernel.bind(swordId).to(Katana); + kernel.bind(bladeId).to(KatanaBlade); + kernel.bind(handlerId).to(KatanaHandler); - kernel.bind>(katanaProviderId).toProvider((context: IContext) => { + kernel.bind>(swordProviderId).toProvider((context: interfaces.Context) => { return () => { - return new Promise((resolve) => { + return new Promise((resolve) => { // Using setTimeout to simulate complex initialization - setTimeout(() => { resolve(context.kernel.get(katanaId)); }, 100); + setTimeout(() => { resolve(context.kernel.get(swordId)); }, 100); }); }; }); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; - let katanaFactoryBinding = _kernel._bindingDictionary.get(katanaProviderId)[0]; + let katanaFactoryBinding = _kernel._bindingDictionary.get(swordProviderId)[0]; let shurikenBinding = _kernel._bindingDictionary.get(shurikenId)[0]; let planner = new Planner(); @@ -806,12 +801,12 @@ describe("Resolver", () => { let ninjaRequest = new Request(ninjaId, context, null, ninjaBinding, null); let plan = new Plan(context, ninjaRequest); - plan.rootRequest.addChildRequest(katanaProviderId, katanaFactoryBinding, new Target("katanaProvider", katanaProviderId)); + plan.rootRequest.addChildRequest(swordProviderId, katanaFactoryBinding, new Target("katanaProvider", swordProviderId)); plan.rootRequest.addChildRequest(shurikenId, shurikenBinding, new Target("shuriken", shurikenId)); context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.shuriken instanceof Shuriken).eql(true); @@ -827,39 +822,39 @@ describe("Resolver", () => { it("Should be able to resolve plans with constraints on tagged targets", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon { } + class Katana implements Weapon { } @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @targetName("katana") @tagged("canThrow", false) katana: IWeapon, - @inject("IWeapon") @targetName("shuriken") @tagged("canThrow", true) shuriken: IWeapon + @inject("Weapon") @targetName("katana") @tagged("canThrow", false) katana: Weapon, + @inject("Weapon") @targetName("shuriken") @tagged("canThrow", true) shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); - kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); + kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -869,7 +864,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -879,39 +874,39 @@ describe("Resolver", () => { it("Should be able to resolve plans with constraints on named targets", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon {} + class Katana implements Weapon {} @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @targetName("katana") @named("strong")katana: IWeapon, - @inject("IWeapon") @targetName("shuriken") @named("weak") shuriken: IWeapon + @inject("Weapon") @targetName("katana") @named("strong")katana: Weapon, + @inject("Weapon") @targetName("shuriken") @named("weak") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Katana).whenTargetNamed("strong"); - kernel.bind(weaponId).to(Shuriken).whenTargetNamed("weak"); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(weaponId).to(Katana).whenTargetNamed("strong"); + kernel.bind(weaponId).to(Shuriken).whenTargetNamed("weak"); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -921,7 +916,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -931,43 +926,43 @@ describe("Resolver", () => { it("Should be able to resolve plans with custom contextual constraints", () => { - interface IWeapon {} + interface Weapon {} @injectable() - class Katana implements IWeapon {} + class Katana implements Weapon {} @injectable() - class Shuriken implements IWeapon {} + class Shuriken implements Weapon {} - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @targetName("katana") katana: IWeapon, - @inject("IWeapon") @targetName("shuriken") shuriken: IWeapon + @inject("Weapon") @targetName("katana") katana: Weapon, + @inject("Weapon") @targetName("shuriken") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; } } - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Katana).when((request: IRequest) => { + kernel.bind(weaponId).to(Katana).when((request: interfaces.Request) => { return request.target.name.equals("katana"); }); - kernel.bind(weaponId).to(Shuriken).when((request: IRequest) => { + kernel.bind(weaponId).to(Shuriken).when((request: interfaces.Request) => { return request.target.name.equals("shuriken"); }); @@ -979,7 +974,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -988,44 +983,44 @@ describe("Resolver", () => { it("Should be able to resolve plans with multi-injections", () => { - interface IWeapon { + interface Weapon { name: string; } @injectable() - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } @injectable() - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface INinja { - katana: IWeapon; - shuriken: IWeapon; + interface Warrior { + katana: Weapon; + shuriken: Weapon; } @injectable() - class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; + class Ninja implements Warrior { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @multiInject("IWeapon") @targetName("weapons") weapons: IWeapon[] + @multiInject("Weapon") @targetName("weapons") weapons: Weapon[] ) { this.katana = weapons[0]; this.shuriken = weapons[1]; } } - let ninjaId = "INinja"; - let weaponId = "IWeapon"; + let ninjaId = "Ninja"; + let weaponId = "Weapon"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(weaponId).to(Katana); - kernel.bind(weaponId).to(Shuriken); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(weaponId).to(Katana); + kernel.bind(weaponId).to(Shuriken); let _kernel: any = kernel; let ninjaBinding = _kernel._bindingDictionary.get(ninjaId)[0]; @@ -1035,7 +1030,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(ninja.katana instanceof Katana).eql(true); @@ -1043,8 +1038,8 @@ describe("Resolver", () => { // if only one value is bound to weaponId let kernel2 = new Kernel(); - kernel2.bind(ninjaId).to(Ninja); - kernel2.bind(weaponId).to(Katana); + kernel2.bind(ninjaId).to(Ninja); + kernel2.bind(weaponId).to(Katana); let _kernel2: any = kernel2; let ninjaBinding2 = _kernel2._bindingDictionary.get(ninjaId)[0]; @@ -1054,7 +1049,7 @@ describe("Resolver", () => { context2.addPlan(plan2); let resolver2 = new Resolver(); - let ninja2 = resolver2.resolve(context2); + let ninja2 = resolver2.resolve(context2); expect(ninja2 instanceof Ninja).eql(true); expect(ninja2.katana instanceof Katana).eql(true); @@ -1063,42 +1058,42 @@ describe("Resolver", () => { it("Should be able to resolve plans with activation handlers", () => { - interface IKatana { + interface Sword { use: () => void; } @injectable() - class Katana implements IKatana { + class Katana implements Sword { public use() { return "Used Katana!"; } } - interface INinja { - katana: IKatana; + interface Warrior { + katana: Katana; } @injectable() - class Ninja implements INinja { - public katana: IKatana; + class Ninja implements Warrior { + public katana: Katana; public constructor( - @inject("IKatana") katana: IKatana + @inject("Katana") katana: Katana ) { this.katana = katana; } } - let ninjaId = "INinja"; - let katanaId = "IKatana"; + let ninjaId = "Ninja"; + let katanaId = "Katana"; let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); + kernel.bind(ninjaId).to(Ninja); // This is a global for unit testing but remember // that it is not a good idea to use globals let timeTracker: string[] = []; - kernel.bind(katanaId).to(Katana).onActivation((context: IContext, katana: IKatana) => { + kernel.bind(katanaId).to(Katana).onActivation((context: interfaces.Context, katana: Katana) => { let handler = { apply: function(target: any, thisArgument: any, argumentsList: any[]) { timeTracker.push(`Starting ${target.name} ${new Date().getTime()}`); @@ -1120,7 +1115,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja.katana.use()).eql("Used Katana!"); expect(Array.isArray(timeTracker)).eql(true); @@ -1130,53 +1125,53 @@ describe("Resolver", () => { it("Should be able to resolve BindingType.Function bindings", () => { - let ninjaId = "INinja"; - let shurikenId = "IShuriken"; + let ninjaId = "Ninja"; + let shurikenId = "Shuriken"; let katanaFactoryId = "KatanaFactory"; interface KatanaFactory extends Function { - (): IKatana; + (): Katana; } - interface IKatanaBlade {} + interface KatanaBlade {} @injectable() - class KatanaBlade implements IKatanaBlade {} + class KatanaBlade implements KatanaBlade {} - interface IKatanaHandler {} + interface KatanaHandler {} @injectable() - class KatanaHandler implements IKatanaHandler {} + class KatanaHandler implements KatanaHandler {} - interface IKatana { - handler: IKatanaHandler; - blade: IKatanaBlade; + interface Sword { + handler: KatanaHandler; + blade: KatanaBlade; } - class Katana implements IKatana { - public handler: IKatanaHandler; - public blade: IKatanaBlade; - public constructor(handler: IKatanaHandler, blade: IKatanaBlade) { + class Katana implements Sword { + public handler: KatanaHandler; + public blade: KatanaBlade; + public constructor(handler: KatanaHandler, blade: KatanaBlade) { this.handler = handler; this.blade = blade; } } - interface IShuriken {} - class Shuriken implements IShuriken {} + interface Shuriken {} + class Shuriken implements Shuriken {} - interface INinja { + interface Warrior { katanaFactory: KatanaFactory; - shuriken: IShuriken; + shuriken: Shuriken; } @injectable() - class Ninja implements INinja { + class Ninja implements Warrior { public katanaFactory: KatanaFactory; - public shuriken: IShuriken; + public shuriken: Shuriken; public constructor( @inject(katanaFactoryId) @targetName("katana") katanaFactory: KatanaFactory, - @inject(shurikenId) @targetName("shuriken") shuriken: IShuriken + @inject(shurikenId) @targetName("shuriken") shuriken: Shuriken ) { this.katanaFactory = katanaFactory; this.shuriken = shuriken; @@ -1184,8 +1179,8 @@ describe("Resolver", () => { } let kernel = new Kernel(); - kernel.bind(ninjaId).to(Ninja); - kernel.bind(shurikenId).to(Shuriken); + kernel.bind(ninjaId).to(Ninja); + kernel.bind(shurikenId).to(Shuriken); let katanaFactory = function() { return new Katana(new KatanaHandler(), new KatanaBlade()); @@ -1215,7 +1210,7 @@ describe("Resolver", () => { context.addPlan(plan); let resolver = new Resolver(); - let ninja = resolver.resolve(context); + let ninja = resolver.resolve(context); expect(ninja instanceof Ninja).eql(true); expect(typeof ninja.katanaFactory === "function").eql(true); diff --git a/test/syntax/binding_in_syntax.test.ts b/test/syntax/binding_in_syntax.test.ts index 3c66b6659..9daa85411 100644 --- a/test/syntax/binding_in_syntax.test.ts +++ b/test/syntax/binding_in_syntax.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import Binding from "../../src/bindings/binding"; import BindingScope from "../../src/bindings/binding_scope"; @@ -9,11 +7,11 @@ describe("BindingInSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInSyntax = new BindingInSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInSyntax = new BindingInSyntax(binding); // cast to any to be able to access private props let _bindingInSyntax: any = bindingInSyntax; @@ -24,11 +22,11 @@ describe("BindingInSyntax", () => { it("Should be able to configure the scope of a binding", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInSyntax = new BindingInSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInSyntax = new BindingInSyntax(binding); // default scope is transient expect(binding.scope).eql(BindingScope.Transient); diff --git a/test/syntax/binding_in_when_on_syntax.test.ts b/test/syntax/binding_in_when_on_syntax.test.ts index bc3756d86..a7b94858c 100644 --- a/test/syntax/binding_in_when_on_syntax.test.ts +++ b/test/syntax/binding_in_when_on_syntax.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Binding from "../../src/bindings/binding"; @@ -20,11 +19,11 @@ describe("BindingInWhenOnSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingInWhenOnSyntax: any = bindingInWhenOnSyntax; @@ -35,11 +34,11 @@ describe("BindingInWhenOnSyntax", () => { it("Should provide access to BindingInSyntax methods", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingInWhenOnSyntax: any = bindingInWhenOnSyntax; @@ -57,21 +56,21 @@ describe("BindingInWhenOnSyntax", () => { it("Should provide access to BindingWhenSyntax methods", () => { - interface IArmy {} + interface Army {} @injectable() - class Army implements IArmy {} + class Army implements Army {} - interface IZombieArmy {} + interface ZombieArmy {} @injectable() - class ZombieArmy implements IZombieArmy {} + class ZombieArmy implements ZombieArmy {} - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingInWhenOnSyntax: any = bindingInWhenOnSyntax; @@ -109,7 +108,7 @@ describe("BindingInWhenOnSyntax", () => { _bindingInWhenOnSyntax._bindingWhenSyntax, "whenNoAncestorMatches").returns(null); // invoke BindingWhenOnSyntax methods - bindingInWhenOnSyntax.when((request: IRequest) => { return true; }); + bindingInWhenOnSyntax.when((request: interfaces.Request) => { return true; }); bindingInWhenOnSyntax.whenTargetNamed("test"); bindingInWhenOnSyntax.whenTargetTagged("test", true); bindingInWhenOnSyntax.whenInjectedInto("armny"); @@ -122,8 +121,8 @@ describe("BindingInWhenOnSyntax", () => { bindingInWhenOnSyntax.whenAnyAncestorTagged("test", true); bindingInWhenOnSyntax.whenNoAncestorNamed("test"); bindingInWhenOnSyntax.whenNoAncestorTagged("test", true); - bindingInWhenOnSyntax.whenAnyAncestorMatches((request: IRequest) => { return true; }); - bindingInWhenOnSyntax.whenNoAncestorMatches((request: IRequest) => { return true; }); + bindingInWhenOnSyntax.whenAnyAncestorMatches((request: interfaces.Request) => { return true; }); + bindingInWhenOnSyntax.whenNoAncestorMatches((request: interfaces.Request) => { return true; }); // assert invoked BindingWhenSyntax methods expect(whenStub.callCount).eql(1); @@ -145,11 +144,11 @@ describe("BindingInWhenOnSyntax", () => { it("Should provide access to BindingOnSyntax methods", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingInWhenOnSyntax = new BindingInWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingInWhenOnSyntax: any = bindingInWhenOnSyntax; @@ -158,7 +157,7 @@ describe("BindingInWhenOnSyntax", () => { let onActivationStub = sinon.stub(_bindingInWhenOnSyntax._bindingOnSyntax, "onActivation").returns(null); // invoke BindingWhenOnSyntax methods - bindingInWhenOnSyntax.onActivation((context: IContext, ninja: INinja) => { + bindingInWhenOnSyntax.onActivation((context: interfaces.Context, ninja: Ninja) => { // DO NOTHING return ninja; }); diff --git a/test/syntax/binding_on_syntax.test.ts b/test/syntax/binding_on_syntax.test.ts index be18a54e7..588a7d850 100644 --- a/test/syntax/binding_on_syntax.test.ts +++ b/test/syntax/binding_on_syntax.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import Binding from "../../src/bindings/binding"; import BindingOnSyntax from "../../src/syntax/binding_on_syntax"; @@ -9,11 +8,11 @@ describe("BindingOnSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingOnSyntax = new BindingOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingOnSyntax = new BindingOnSyntax(binding); // cast to any to be able to access private props let _bindingOnSyntax: any = bindingOnSyntax; @@ -24,15 +23,15 @@ describe("BindingOnSyntax", () => { it("Should be able to configure the activation handler of a binding", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingOnSyntax = new BindingOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingOnSyntax = new BindingOnSyntax(binding); - bindingOnSyntax.onActivation((context: IContext, ninja: INinja) => { + bindingOnSyntax.onActivation((context: interfaces.Context, ninja: Ninja) => { let handler = {}; - return new Proxy(ninja, handler); + return new Proxy(ninja, handler); }); expect(binding.onActivation).not.to.eql(null); diff --git a/test/syntax/binding_to_syntax.test.ts b/test/syntax/binding_to_syntax.test.ts index 4bdc5b955..f95390801 100644 --- a/test/syntax/binding_to_syntax.test.ts +++ b/test/syntax/binding_to_syntax.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import Binding from "../../src/bindings/binding"; import BindingType from "../../src/bindings/binding_type"; @@ -11,11 +10,11 @@ describe("BindingToSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingToSyntax = new BindingToSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingToSyntax = new BindingToSyntax(binding); // cast to any to be able to access private props let _bindingToSyntax: any = bindingToSyntax; @@ -26,14 +25,14 @@ describe("BindingToSyntax", () => { it("Should be able to configure the type of a binding", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaIdentifier = "INinja"; + class Ninja implements Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingToSyntax = new BindingToSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingToSyntax = new BindingToSyntax(binding); expect(binding.type).eql(BindingType.Invalid); @@ -50,11 +49,11 @@ describe("BindingToSyntax", () => { expect(typeof binding.dynamicValue).eql("function"); expect(binding.dynamicValue() instanceof Ninja).eql(true); - bindingToSyntax.toConstructor(Ninja); + bindingToSyntax.toConstructor(Ninja); expect(binding.type).eql(BindingType.Constructor); expect(binding.implementationType).not.to.eql(null); - bindingToSyntax.toFactory((context) => { + bindingToSyntax.toFactory((context: interfaces.Context) => { return () => { return new Ninja(); }; @@ -68,14 +67,14 @@ describe("BindingToSyntax", () => { expect(binding.type).eql(BindingType.Function); expect(binding.cache === f).eql(true); - bindingToSyntax.toAutoFactory(ninjaIdentifier); + bindingToSyntax.toAutoFactory(ninjaIdentifier); expect(binding.type).eql(BindingType.Factory); expect(binding.factory).not.to.eql(null); - bindingToSyntax.toProvider((context) => { + bindingToSyntax.toProvider((context: interfaces.Context) => { return () => { - return new Promise((resolve) => { + return new Promise((resolve) => { resolve(new Ninja()); }); }; @@ -88,14 +87,14 @@ describe("BindingToSyntax", () => { it("Should prevent invalid function bindings", () => { - interface INinja {} + interface Ninja {} @injectable() - class Ninja implements INinja {} - let ninjaIdentifier = "INinja"; + class Ninja implements Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingToSyntax = new BindingToSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingToSyntax = new BindingToSyntax(binding); let f = function () { bindingToSyntax.toFunction(5); diff --git a/test/syntax/binding_when_on_syntax.test.ts b/test/syntax/binding_when_on_syntax.test.ts index 0b20b923f..40d4f4868 100644 --- a/test/syntax/binding_when_on_syntax.test.ts +++ b/test/syntax/binding_when_on_syntax.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import * as sinon from "sinon"; import Binding from "../../src/bindings/binding"; @@ -20,11 +19,11 @@ describe("BindingWhenOnSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingWhenOnSyntax: any = bindingWhenOnSyntax; @@ -35,21 +34,21 @@ describe("BindingWhenOnSyntax", () => { it("Should provide access to BindingWhenSyntax methods", () => { - interface IArmy {} + interface Army {} @injectable() - class Army implements IArmy {} + class Army implements Army {} - interface IZombieArmy {} + interface ZombieArmy {} @injectable() - class ZombieArmy implements IZombieArmy {} + class ZombieArmy implements ZombieArmy {} - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingWhenOnSyntax: any = bindingWhenOnSyntax; @@ -87,7 +86,7 @@ describe("BindingWhenOnSyntax", () => { _bindingWhenOnSyntax._bindingWhenSyntax, "whenNoAncestorMatches").returns(null); // invoke BindingWhenOnSyntax methods - bindingWhenOnSyntax.when((request: IRequest) => { return true; }); + bindingWhenOnSyntax.when((request: interfaces.Request) => { return true; }); bindingWhenOnSyntax.whenTargetNamed("test"); bindingWhenOnSyntax.whenTargetTagged("test", true); bindingWhenOnSyntax.whenInjectedInto("armny"); @@ -100,8 +99,8 @@ describe("BindingWhenOnSyntax", () => { bindingWhenOnSyntax.whenAnyAncestorTagged("test", true); bindingWhenOnSyntax.whenNoAncestorNamed("test"); bindingWhenOnSyntax.whenNoAncestorTagged("test", true); - bindingWhenOnSyntax.whenAnyAncestorMatches((request: IRequest) => { return true; }); - bindingWhenOnSyntax.whenNoAncestorMatches((request: IRequest) => { return true; }); + bindingWhenOnSyntax.whenAnyAncestorMatches((request: interfaces.Request) => { return true; }); + bindingWhenOnSyntax.whenNoAncestorMatches((request: interfaces.Request) => { return true; }); // assert invoked BindingWhenSyntax methods expect(whenStub.callCount).eql(1); @@ -123,11 +122,11 @@ describe("BindingWhenOnSyntax", () => { it("Should provide access to BindingOnSyntax methods", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenOnSyntax = new BindingWhenOnSyntax(binding); // cast to any to be able to access private props let _bindingWhenOnSyntax: any = bindingWhenOnSyntax; @@ -136,7 +135,7 @@ describe("BindingWhenOnSyntax", () => { let onActivationStub = sinon.stub(_bindingWhenOnSyntax._bindingOnSyntax, "onActivation").returns(null); // invoke BindingWhenOnSyntax methods - bindingWhenOnSyntax.onActivation((context: IContext, ninja: INinja) => { + bindingWhenOnSyntax.onActivation((context: interfaces.Context, ninja: Ninja) => { // DO NOTHING return ninja; }); diff --git a/test/syntax/binding_when_syntax.test.ts b/test/syntax/binding_when_syntax.test.ts index 11ee134c8..6c993319f 100644 --- a/test/syntax/binding_when_syntax.test.ts +++ b/test/syntax/binding_when_syntax.test.ts @@ -1,5 +1,4 @@ -/// - +import interfaces from "../../src/interfaces/interfaces"; import { expect } from "chai"; import Binding from "../../src/bindings/binding"; import Request from "../../src/planning/request"; @@ -12,11 +11,11 @@ describe("BindingWhenSyntax", () => { it("Should set its own properties correctly", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenSyntax = new BindingWhenSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenSyntax = new BindingWhenSyntax(binding); // cast to any to be able to access private props let _bindingWhenSyntax: any = bindingWhenSyntax; @@ -27,13 +26,13 @@ describe("BindingWhenSyntax", () => { it("Should be able to configure custom constraint of a binding", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenSyntax = new BindingWhenSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenSyntax = new BindingWhenSyntax(binding); - bindingWhenSyntax.when((request: IRequest) => { + bindingWhenSyntax.when((request: interfaces.Request) => { return request.target.name.equals("ninja"); }); @@ -45,11 +44,11 @@ describe("BindingWhenSyntax", () => { it("Should be able to constraint a binding to a named target", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenSyntax = new BindingWhenSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenSyntax = new BindingWhenSyntax(binding); let named = "primary"; @@ -68,11 +67,11 @@ describe("BindingWhenSyntax", () => { it("Should be able to constraint a binding to a tagged target", () => { - interface INinja {} - let ninjaIdentifier = "INinja"; + interface Ninja {} + let ninjaIdentifier = "Ninja"; - let binding = new Binding(ninjaIdentifier); - let bindingWhenSyntax = new BindingWhenSyntax(binding); + let binding = new Binding(ninjaIdentifier); + let bindingWhenSyntax = new BindingWhenSyntax(binding); bindingWhenSyntax.whenTargetTagged("canSwim", true); expect(binding.constraint).not.to.eql(null); @@ -89,57 +88,57 @@ describe("BindingWhenSyntax", () => { it("Should be able to constraint a binding to its parent", () => { - interface IWeapon { + interface Weapon { name: string; } - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface ISamurai { - katana: IWeapon; + interface JaponeseWarrior { + katana: Weapon; } - interface INinja { - shuriken: IWeapon; + interface ChineseWarrior { + shuriken: Weapon; } - class Ninja implements INinja { - public shuriken: IWeapon; - public constructor(shuriken: IWeapon) { + class Ninja implements ChineseWarrior { + public shuriken: Weapon; + public constructor(shuriken: Weapon) { this.shuriken = shuriken; } } - class Samurai implements ISamurai { - public katana: IWeapon; - public constructor(katana: IWeapon) { + class Samurai implements JaponeseWarrior { + public katana: Weapon; + public constructor(katana: Weapon) { this.katana = katana; } } - let samuraiBinding = new Binding("ISamurai"); + let samuraiBinding = new Binding("Samurai"); samuraiBinding.implementationType = Samurai; - let samuraiRequest = new Request("ISamurai", null, null, samuraiBinding, null); + let samuraiRequest = new Request("Samurai", null, null, samuraiBinding, null); - let ninjaBinding = new Binding("INinja"); + let ninjaBinding = new Binding("Ninja"); ninjaBinding.implementationType = Ninja; - let ninjaRequest = new Request("INinja", null, null, ninjaBinding, null); + let ninjaRequest = new Request("Ninja", null, null, ninjaBinding, null); - let katanaBinding = new Binding("IWeapon"); - let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); - let katanaTarget = new Target("katana", "IWeapon"); - let katanaRequest = new Request("IWeapon", null, samuraiRequest, katanaBinding, katanaTarget); + let katanaBinding = new Binding("Weapon"); + let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); + let katanaTarget = new Target("katana", "Weapon"); + let katanaRequest = new Request("Weapon", null, samuraiRequest, katanaBinding, katanaTarget); - let shurikenBinding = new Binding("IWeapon"); - let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); - let shurikenTarget = new Target("shuriken", "IWeapon"); - let shurikenRequest = new Request("IWeapon", null, ninjaRequest, shurikenBinding, shurikenTarget); + let shurikenBinding = new Binding("Weapon"); + let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); + let shurikenTarget = new Target("shuriken", "Weapon"); + let shurikenRequest = new Request("Weapon", null, ninjaRequest, shurikenBinding, shurikenTarget); katanaBindingWhenSyntax.whenInjectedInto(Samurai); expect(katanaBinding.constraint(katanaRequest)).eql(true); @@ -157,19 +156,19 @@ describe("BindingWhenSyntax", () => { expect(shurikenBinding.constraint(katanaRequest)).eql(false); expect(shurikenBinding.constraint(shurikenRequest)).eql(true); - katanaBindingWhenSyntax.whenInjectedInto("ISamurai"); + katanaBindingWhenSyntax.whenInjectedInto("Samurai"); expect(katanaBinding.constraint(katanaRequest)).eql(true); expect(katanaBinding.constraint(shurikenRequest)).eql(false); - katanaBindingWhenSyntax.whenInjectedInto("INinja"); + katanaBindingWhenSyntax.whenInjectedInto("Ninja"); expect(katanaBinding.constraint(katanaRequest)).eql(false); expect(katanaBinding.constraint(shurikenRequest)).eql(true); - shurikenBindingWhenSyntax.whenInjectedInto("ISamurai"); + shurikenBindingWhenSyntax.whenInjectedInto("Samurai"); expect(shurikenBinding.constraint(katanaRequest)).eql(true); expect(shurikenBinding.constraint(shurikenRequest)).eql(false); - shurikenBindingWhenSyntax.whenInjectedInto("INinja"); + shurikenBindingWhenSyntax.whenInjectedInto("Ninja"); expect(shurikenBinding.constraint(katanaRequest)).eql(false); expect(shurikenBinding.constraint(shurikenRequest)).eql(true); @@ -177,57 +176,57 @@ describe("BindingWhenSyntax", () => { it("Should be able to constraint a binding to a named parent", () => { - interface IWeapon { + interface Weapon { name: string; } - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface ISamurai { - katana: IWeapon; + interface JaponeseWarrior { + katana: Weapon; } - interface INinja { - shuriken: IWeapon; + interface ChineseWarrior { + shuriken: Weapon; } - class Ninja implements INinja { - public shuriken: IWeapon; - public constructor(shuriken: IWeapon) { + class Ninja implements ChineseWarrior { + public shuriken: Weapon; + public constructor(shuriken: Weapon) { this.shuriken = shuriken; } } - class Samurai implements ISamurai { - public katana: IWeapon; - public constructor(katana: IWeapon) { + class Samurai implements JaponeseWarrior { + public katana: Weapon; + public constructor(katana: Weapon) { this.katana = katana; } } - let samuraiBinding = new Binding("ISamurai"); + let samuraiBinding = new Binding("Samurai"); samuraiBinding.implementationType = Samurai; - let samuraiRequest = new Request("ISamurai", null, null, samuraiBinding, new Target(null, "ISamurai", "japonese")); + let samuraiRequest = new Request("Samurai", null, null, samuraiBinding, new Target(null, "Samurai", "japonese")); - let ninjaBinding = new Binding("INinja"); + let ninjaBinding = new Binding("Ninja"); ninjaBinding.implementationType = Ninja; - let ninjaRequest = new Request("INinja", null, null, ninjaBinding, new Target(null, "INinja", "chinese")); + let ninjaRequest = new Request("Ninja", null, null, ninjaBinding, new Target(null, "Ninja", "chinese")); - let katanaBinding = new Binding("IWeapon"); - let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); - let katanaTarget = new Target("katana", "IWeapon"); - let katanaRequest = new Request("IWeapon", null, samuraiRequest, katanaBinding, katanaTarget); + let katanaBinding = new Binding("Weapon"); + let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); + let katanaTarget = new Target("katana", "Weapon"); + let katanaRequest = new Request("Weapon", null, samuraiRequest, katanaBinding, katanaTarget); - let shurikenBinding = new Binding("IWeapon"); - let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); - let shurikenTarget = new Target("shuriken", "IWeapon"); - let shurikenRequest = new Request("IWeapon", null, ninjaRequest, shurikenBinding, shurikenTarget); + let shurikenBinding = new Binding("Weapon"); + let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); + let shurikenTarget = new Target("shuriken", "Weapon"); + let shurikenRequest = new Request("Weapon", null, ninjaRequest, shurikenBinding, shurikenTarget); katanaBindingWhenSyntax.whenParentNamed("chinese"); shurikenBindingWhenSyntax.whenParentNamed("chinese"); @@ -243,59 +242,59 @@ describe("BindingWhenSyntax", () => { it("Should be able to constraint a binding to a tagged parent", () => { - interface IWeapon { + interface Weapon { name: string; } - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; } - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; } - interface ISamurai { - katana: IWeapon; + interface JaponeseWarrior { + katana: Weapon; } - interface INinja { - shuriken: IWeapon; + interface ChineseWarrior { + shuriken: Weapon; } - class Ninja implements INinja { - public shuriken: IWeapon; - public constructor(shuriken: IWeapon) { + class Ninja implements ChineseWarrior { + public shuriken: Weapon; + public constructor(shuriken: Weapon) { this.shuriken = shuriken; } } - class Samurai implements ISamurai { - public katana: IWeapon; - public constructor(katana: IWeapon) { + class Samurai implements JaponeseWarrior { + public katana: Weapon; + public constructor(katana: Weapon) { this.katana = katana; } } - let samuraiBinding = new Binding("ISamurai"); + let samuraiBinding = new Binding("Samurai"); samuraiBinding.implementationType = Samurai; - let samuraiTarget = new Target(null, "ISamurai", new Metadata("sneaky", false)); - let samuraiRequest = new Request("ISamurai", null, null, samuraiBinding, samuraiTarget); + let samuraiTarget = new Target(null, "Samurai", new Metadata("sneaky", false)); + let samuraiRequest = new Request("Samurai", null, null, samuraiBinding, samuraiTarget); - let ninjaBinding = new Binding("INinja"); + let ninjaBinding = new Binding("Ninja"); ninjaBinding.implementationType = Ninja; - let ninjaTarget = new Target(null, "INinja", new Metadata("sneaky", true)); - let ninjaRequest = new Request("INinja", null, null, ninjaBinding, ninjaTarget); + let ninjaTarget = new Target(null, "Ninja", new Metadata("sneaky", true)); + let ninjaRequest = new Request("Ninja", null, null, ninjaBinding, ninjaTarget); - let katanaBinding = new Binding("IWeapon"); - let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); - let katanaTarget = new Target("katana", "IWeapon"); - let katanaRequest = new Request("IWeapon", null, samuraiRequest, katanaBinding, katanaTarget); + let katanaBinding = new Binding("Weapon"); + let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); + let katanaTarget = new Target("katana", "Weapon"); + let katanaRequest = new Request("Weapon", null, samuraiRequest, katanaBinding, katanaTarget); - let shurikenBinding = new Binding("IWeapon"); - let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); - let shurikenTarget = new Target("shuriken", "IWeapon"); - let shurikenRequest = new Request("IWeapon", null, ninjaRequest, shurikenBinding, shurikenTarget); + let shurikenBinding = new Binding("Weapon"); + let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); + let shurikenTarget = new Target("shuriken", "Weapon"); + let shurikenRequest = new Request("Weapon", null, ninjaRequest, shurikenBinding, shurikenTarget); katanaBindingWhenSyntax.whenParentTagged("sneaky", true); shurikenBindingWhenSyntax.whenParentTagged("sneaky", true); @@ -311,112 +310,112 @@ describe("BindingWhenSyntax", () => { describe("BindingWhenSyntax.when*Ancestor*()", () => { - interface IMaterial { + interface Material { name: string; } - class Wood implements IMaterial { + class Wood implements Material { public name = "Wood"; } - class Iron implements IMaterial { + class Iron implements Material { public name = "Iron"; } - interface IWeapon { + interface Weapon { name: string; - material: IMaterial; + material: Material; } - class Katana implements IWeapon { + class Katana implements Weapon { public name = "Katana"; - public material: IMaterial; - public contructor(material: IMaterial) { + public material: Material; + public contructor(material: Material) { this.material = material; } } - class Shuriken implements IWeapon { + class Shuriken implements Weapon { public name = "Shuriken"; - public material: IMaterial; - public contructor(material: IMaterial) { + public material: Material; + public contructor(material: Material) { this.material = material; } } - interface ISamurai { - katana: IWeapon; + interface Samurai { + katana: Weapon; } - interface INinja { - shuriken: IWeapon; + interface Ninja { + shuriken: Weapon; } - class NinjaMaster implements INinja { - public shuriken: IWeapon; - public constructor(shuriken: IWeapon) { + class NinjaMaster implements Ninja { + public shuriken: Weapon; + public constructor(shuriken: Weapon) { this.shuriken = shuriken; } } - class SamuraiMaster implements ISamurai { - public katana: IWeapon; - public constructor(katana: IWeapon) { + class SamuraiMaster implements Samurai { + public katana: Weapon; + public constructor(katana: Weapon) { this.katana = katana; } } - class NinjaStudent implements INinja { - public shuriken: IWeapon; - public constructor(shuriken: IWeapon) { + class NinjaStudent implements Ninja { + public shuriken: Weapon; + public constructor(shuriken: Weapon) { this.shuriken = shuriken; } } - class SamuraiStudent implements ISamurai { - public katana: IWeapon; - public constructor(katana: IWeapon) { + class SamuraiStudent implements Samurai { + public katana: Weapon; + public constructor(katana: Weapon) { this.katana = katana; } } // Samurai - let samuraiMasterBinding = new Binding("ISamurai"); + let samuraiMasterBinding = new Binding("Samurai"); samuraiMasterBinding.implementationType = SamuraiMaster; - let samuraiStudentBinding = new Binding("ISamurai"); + let samuraiStudentBinding = new Binding("Samurai"); samuraiStudentBinding.implementationType = SamuraiStudent; - let samuraiTarget = new Target(null, "ISamurai", new Metadata("sneaky", false)); - let samuraiMasterRequest = new Request("ISamurai", null, null, samuraiMasterBinding, samuraiTarget); - let samuraiStudentRequest = new Request("ISamurai", null, null, samuraiStudentBinding, samuraiTarget); + let samuraiTarget = new Target(null, "Samurai", new Metadata("sneaky", false)); + let samuraiMasterRequest = new Request("Samurai", null, null, samuraiMasterBinding, samuraiTarget); + let samuraiStudentRequest = new Request("Samurai", null, null, samuraiStudentBinding, samuraiTarget); // Ninja - let ninjaMasterBinding = new Binding("INinja"); + let ninjaMasterBinding = new Binding("Ninja"); ninjaMasterBinding.implementationType = NinjaMaster; - let ninjaStudentBinding = new Binding("INinja"); + let ninjaStudentBinding = new Binding("Ninja"); ninjaStudentBinding.implementationType = NinjaStudent; - let ninjaTarget = new Target(null, "INinja", new Metadata("sneaky", true)); - let ninjaMasterRequest = new Request("INinja", null, null, ninjaMasterBinding, ninjaTarget); - let ninjaStudentRequest = new Request("INinja", null, null, ninjaStudentBinding, ninjaTarget); + let ninjaTarget = new Target(null, "Ninja", new Metadata("sneaky", true)); + let ninjaMasterRequest = new Request("Ninja", null, null, ninjaMasterBinding, ninjaTarget); + let ninjaStudentRequest = new Request("Ninja", null, null, ninjaStudentBinding, ninjaTarget); // Katana - let katanaBinding = new Binding("IWeapon"); + let katanaBinding = new Binding("Weapon"); katanaBinding.implementationType = Katana; - let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); - let katanaTarget = new Target("katana", "IWeapon"); - let ironKatanaRequest = new Request("IWeapon", null, samuraiMasterRequest, katanaBinding, katanaTarget); - let woodKatanaRequest = new Request("IWeapon", null, samuraiStudentRequest, katanaBinding, katanaTarget); + let katanaBindingWhenSyntax = new BindingWhenSyntax(katanaBinding); + let katanaTarget = new Target("katana", "Weapon"); + let ironKatanaRequest = new Request("Weapon", null, samuraiMasterRequest, katanaBinding, katanaTarget); + let woodKatanaRequest = new Request("Weapon", null, samuraiStudentRequest, katanaBinding, katanaTarget); // Shuriken - let shurikenBinding = new Binding("IWeapon"); + let shurikenBinding = new Binding("Weapon"); shurikenBinding.implementationType = Shuriken; - let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); - let shurikenTarget = new Target("shuriken", "IWeapon"); - let ironShurikenRequest = new Request("IWeapon", null, ninjaMasterRequest, shurikenBinding, shurikenTarget); - let woodShurikenRequest = new Request("IWeapon", null, ninjaStudentRequest, shurikenBinding, shurikenTarget); + let shurikenBindingWhenSyntax = new BindingWhenSyntax(shurikenBinding); + let shurikenTarget = new Target("shuriken", "Weapon"); + let ironShurikenRequest = new Request("Weapon", null, ninjaMasterRequest, shurikenBinding, shurikenTarget); + let woodShurikenRequest = new Request("Weapon", null, ninjaStudentRequest, shurikenBinding, shurikenTarget); it("Should be able to apply a type constraint to some of its ancestors", () => { diff --git a/test/utils/guid.test.ts b/test/utils/guid.test.ts index 79bcbb477..9674d2d71 100644 --- a/test/utils/guid.test.ts +++ b/test/utils/guid.test.ts @@ -1,5 +1,3 @@ -/// - import { expect } from "chai"; import guid from "../../src/utils/guid"; diff --git a/test/utils/stubs.ts b/test/utils/stubs.ts index d85015e38..f978a4823 100644 --- a/test/utils/stubs.ts +++ b/test/utils/stubs.ts @@ -54,12 +54,12 @@ export class FooBar implements FooBarInterface { // 2.0 -export interface IWeapon {} -export interface IKatana extends IWeapon {} -export interface IShuriken extends IWeapon {} +export interface Weapon {} +export interface Katana extends Weapon {} +export interface Shuriken extends Weapon {} -export class Katana implements IKatana {} -export class Shuriken implements IShuriken {} +export class Katana implements Katana {} +export class Shuriken implements Shuriken {} export class WarriotWithoutInjections {} @@ -68,12 +68,12 @@ export class DecoratedWarriotWithoutInjections {} @injectable() export class Warrior { - private _primaryWeapon: IKatana; - private _secondaryWeapon: IShuriken; + private _primaryWeapon: Katana; + private _secondaryWeapon: Shuriken; constructor( - @inject("IKatana") primary: IKatana, - @inject("IShuriken") secondary: IShuriken + @inject("Katana") primary: Katana, + @inject("Shuriken") secondary: Shuriken ) { // ... } @@ -81,24 +81,24 @@ export class Warrior { export class InvalidDecoratorUsageWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - primary: IWeapon, - secondary: IWeapon) { + primary: Weapon, + secondary: Weapon) { // ... } } export class MissingInjectionWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - primary: IWeapon, - secondary: IWeapon) { + primary: Weapon, + secondary: Weapon) { // ... } } @@ -106,12 +106,12 @@ export class MissingInjectionWarrior { @injectable() export class NamedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @inject("IKatana") @named("strong") primary: IWeapon, - @inject("IShuriken") @named("weak") secondary: IWeapon + @inject("Katana") @named("strong") primary: Weapon, + @inject("Shuriken") @named("weak") secondary: Weapon ) { // ... } @@ -120,12 +120,12 @@ export class NamedWarrior { @injectable() export class TaggedWarrior { - private _primaryWeapon: IWeapon; - private _secondaryWeapon: IWeapon; + private _primaryWeapon: Weapon; + private _secondaryWeapon: Weapon; constructor( - @inject("IKatana") @tagged("power", 5) primary: IWeapon, - @inject("IShuriken") @tagged("power", 1) secondary: IWeapon + @inject("Katana") @tagged("power", 5) primary: Weapon, + @inject("Shuriken") @tagged("power", 1) secondary: Weapon ) { // ... } @@ -133,9 +133,9 @@ export class TaggedWarrior { @injectable() export abstract class BaseSoldier { - public weapon: IWeapon; + public weapon: Weapon; public constructor( - @inject("IWeapon") weapon: IWeapon + @inject("Weapon") weapon: Weapon ) { this.weapon = weapon; } diff --git a/tsconfig.json b/tsconfig.json index 8ccad8811..8fb292630 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -14,9 +14,10 @@ "preserveConstEnums": true, "suppressImplicitAnyIndexErrors": false }, - "exclude": [ - "node_modules", - "type_definitions", - "typings" + "files": [ + "./typings/index.d.ts", + "./node_modules/reflect-metadata/reflect-metadata.d.ts", + "./src/interfaces/globals.d.ts", + "./src/inversify.ts" ] } \ No newline at end of file diff --git a/wiki/activation_handler.md b/wiki/activation_handler.md index 9801c7b51..d8af041f3 100644 --- a/wiki/activation_handler.md +++ b/wiki/activation_handler.md @@ -1,35 +1,41 @@ # Activation handler -It is possible to add an activation handler for a type. The activation handler is invoked after a dependency has been resolved and before it is added to the cache (if singleton) and injected. This is useful to keep our dependencies agnostic of the implementation of crosscutting concerns like caching or logging. The following example uses a [proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) to intercept one of the methods (`use`) of a dependency (`IKatana`). + +It is possible to add an activation handler for a type. The activation handler is +invoked after a dependency has been resolved and before it is added to the cache +(if singleton) and injected. This is useful to keep our dependencies agnostic of +the implementation of crosscutting concerns like caching or logging. The following +example uses a [proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) +to intercept one of the methods (`use`) of a dependency (`Katana`). ```ts -interface IKatana { +interface Katana { use: () => void; } @injectable() -class Katana implements IKatana { +class Katana implements Katana { public use() { console.log("Used Katana!"); } } -interface INinja { - katana: IKatana; +interface Ninja { + katana: Katana; } @injectable() -class Ninja implements INinja { - public katana: IKatana; - public constructor(@inject("IKatana") katana: IKatana) { +class Ninja implements Ninja { + public katana: Katana; + public constructor(@inject("Katana") katana: Katana) { this.katana = katana; } } ``` ```ts -kernel.bind("INinja").to(Ninja); +kernel.bind("Ninja").to(Ninja); -kernel.bind("IKatana").to(Katana).onActivation((context, katana) => { +kernel.bind("Katana").to(Katana).onActivation((context, katana) => { let handler = { apply: function(target, thisArgument, argumentsList) { console.log(`Starting: ${new Date().getTime()}`); @@ -44,7 +50,7 @@ kernel.bind("IKatana").to(Katana).onActivation((context, katana) => { ``` ```ts -let ninja = kernelget(); +let ninja = kernelget(); ninja.katana.use(); > Starting: 1457895135761 > Used Katana! diff --git a/wiki/architecture.md b/wiki/architecture.md index 21e2de6eb..b401b4f8c 100644 --- a/wiki/architecture.md +++ b/wiki/architecture.md @@ -57,7 +57,7 @@ The annotation phase reads the metadata generated by the decorators and transfor ### Planning Phase When we invoke the following: ``` -var obj = kernel.get("ISomeType"); +var obj = kernel.get("SomeType"); ``` We start a new resolution, which means that the kernel will create a new resolution context. The resolution context contains a reference to the kernel and a reference to a Plan. diff --git a/wiki/auto_factory.md b/wiki/auto_factory.md index c65522caf..3ee3b39f8 100644 --- a/wiki/auto_factory.md +++ b/wiki/auto_factory.md @@ -1,15 +1,17 @@ # Auto factory + Binds an abstraction to a auto-generated Factory. + ```ts @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IFactory") katanaFactory: IFactory, - @inject("IShuriken") shuriken: IShuriken + @inject("Factory") katanaFactory: interfaces.Factory, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katanaFactory(); this._shuriken = shuriken; @@ -22,6 +24,6 @@ class Ninja implements INinja { ``` ```ts -kernel.bind>("IFactory") - .toAutoFactory("IKatana"); +kernel.bind>("Factory") + .toAutoFactory("Katana"); ``` diff --git a/wiki/circular_dependencies.md b/wiki/circular_dependencies.md index e03886e9c..3d63c36f7 100644 --- a/wiki/circular_dependencies.md +++ b/wiki/circular_dependencies.md @@ -3,5 +3,5 @@ InversifyJS is able to identify circular dependencies and will throw an exceptio to identify the location of the problem if a circular dependency is detected: ```ts -Error: Circular dependency found between services: IKatana and INinja +Error: Circular dependency found between services: Katana and Ninja ``` diff --git a/wiki/classes_as_id.md b/wiki/classes_as_id.md index f7d94ffdc..8554088c7 100644 --- a/wiki/classes_as_id.md +++ b/wiki/classes_as_id.md @@ -18,7 +18,7 @@ class Shuriken { } @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { private _katana: Katana; private _shuriken: Shuriken; diff --git a/wiki/constructor_injection.md b/wiki/constructor_injection.md index 78c2cf115..9dd03c466 100644 --- a/wiki/constructor_injection.md +++ b/wiki/constructor_injection.md @@ -1,15 +1,17 @@ # Injecting a class constructor + Binds an abstraction to a class constructor. + ```ts @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("INewable") Katana: INewable, - @inject("IShuriken") shuriken: IShuriken + @inject("Newable") Katana: Newable, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = new Katana(); this._shuriken = shuriken; @@ -22,5 +24,5 @@ class Ninja implements INinja { ``` ```ts -kernel.bind>("INewable").toConstructor(Katana); +kernel.bind>("Newable").toConstructor(Katana); ``` diff --git a/wiki/contextual_bindings.md b/wiki/contextual_bindings.md index 596a757b1..d9da7fc54 100644 --- a/wiki/contextual_bindings.md +++ b/wiki/contextual_bindings.md @@ -5,26 +5,26 @@ becomes `constructor(a, b) { ...` after compression but thanks to `@targetName` refer to the design-time names `katana` and `shuriken` at runtime. ```ts -interface IWeapon {} +interface Weapon {} @injectable() -class Katana implements IWeapon {} +class Katana implements Weapon {} @injectable() -class Shuriken implements IWeapon {} +class Shuriken implements Weapon {} -interface INinja { - katana: IWeapon; - shuriken: IWeapon; +interface Ninja { + katana: Weapon; + shuriken: Weapon; } @injectable() -class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; +class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @targetName("katana") katana: IWeapon, - @inject("IWeapon") @targetName("shuriken") shuriken: IWeapon + @inject("Weapon") @targetName("katana") katana: Weapon, + @inject("Weapon") @targetName("shuriken") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -32,16 +32,16 @@ class Ninja implements INinja { } ``` -We are binding `Katana` and `Shuriken` to `IWeapon` but a custom `when` constraint is added to avoid `AMBIGUOUS_MATCH` errors: +We are binding `Katana` and `Shuriken` to `Weapon` but a custom `when` constraint is added to avoid `AMBIGUOUS_MATCH` errors: ```ts -kernel.bind(ninjaId).to(Ninja); +kernel.bind(ninjaId).to(Ninja); -kernel.bind("IWeapon").to(Katana).when((request: IRequest) => { +kernel.bind("Weapon").to(Katana).when((request: interfaces.Request) => { return request.target.name.equals("katana"); }); -kernel.bind("IWeapon").to(Shuriken).when((request: IRequest) => { +kernel.bind("Weapon").to(Shuriken).when((request: interfaces.Request) => { return request.target.name.equals("shuriken"); }); ``` @@ -49,7 +49,7 @@ kernel.bind("IWeapon").to(Shuriken).when((request: IRequest) => { The target fields implement the `IQueryableString` interface to help you to create your custom constraints: ```ts -interface IQueryableString { +interface QueryableString { startsWith(searchString: string): boolean; endsWith(searchString: string): boolean; contains(searchString: string): boolean; @@ -62,15 +62,15 @@ We have included some helpers to facilitate the creation of custom constraints: ```ts import { Kernel, traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint } from "inversify"; -let whenParentNamedCanThrowConstraint = (request: IRequest) => { +let whenParentNamedCanThrowConstraint = (request: interfaces.Request) => { return namedConstraint("canThrow")(request.parentRequest); }; -let whenAnyAncestorIsConstraint = (request: IRequest) => { +let whenAnyAncestorIsConstraint = (request: interfaces.Request) => { return traverseAncerstors(request, typeConstraint(Ninja)); }; -let whenAnyAncestorTaggedConstraint = (request: IRequest) => { +let whenAnyAncestorTaggedConstraint = (request: interfaces.Request) => { return traverseAncerstors(request, taggedConstraint("canThrow")(true)); }; ``` @@ -78,20 +78,20 @@ let whenAnyAncestorTaggedConstraint = (request: IRequest) => { The InversifyJS fluent syntax for bindings includes some already implemented common contextual constraints: ```ts -interface IBindingWhenSyntax { - when(constraint: (request: IRequest) => boolean): IBindingOnSyntax; - whenTargetNamed(name: string): IBindingOnSyntax; - whenTargetTagged(tag: string, value: any): IBindingOnSyntax; - whenInjectedInto(parent: (Function|string)): IBindingOnSyntax; - whenParentNamed(name: string): IBindingOnSyntax; - whenParentTagged(tag: string, value: any): IBindingOnSyntax; - whenAnyAncestorIs(ancestor: (Function|string)): IBindingOnSyntax; - whenNoAncestorIs(ancestor: (Function|string)): IBindingOnSyntax; - whenAnyAncestorNamed(name: string): IBindingOnSyntax; - whenAnyAncestorTagged(tag: string, value: any): IBindingOnSyntax; - whenNoAncestorNamed(name: string): IBindingOnSyntax; - whenNoAncestorTagged(tag: string, value: any): IBindingOnSyntax; - whenAnyAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax; - whenNoAncestorMatches(constraint: (request: IRequest) => boolean): IBindingOnSyntax; +interface BindingWhenSyntax { + when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax; + whenTargetNamed(name: string): interfaces.BindingOnSyntax; + whenTargetTagged(tag: string, value: any): interfaces.BindingOnSyntax; + whenInjectedInto(parent: (Function|string)): interfaces.BindingOnSyntax; + whenParentNamed(name: string): interfaces.BindingOnSyntax; + whenParentTagged(tag: string, value: any): interfaces.BindingOnSyntax; + whenAnyAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax; + whenNoAncestorIs(ancestor: (Function|string)): interfaces.BindingOnSyntax; + whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax; + whenAnyAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax; + whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax; + whenNoAncestorTagged(tag: string, value: any): interfaces.BindingOnSyntax; + whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax; + whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax; } ``` diff --git a/wiki/custom_tag_decorators.md b/wiki/custom_tag_decorators.md index 394afed69..bdfd69e76 100644 --- a/wiki/custom_tag_decorators.md +++ b/wiki/custom_tag_decorators.md @@ -7,12 +7,12 @@ let throwable = tagged("canThrow", true); let notThrowable = tagged("canThrow", false); @injectable() -class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; +class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @notThrowable katana: IWeapon, - @inject("IWeapon") @throwable shuriken: IWeapon + @inject("Weapon") @notThrowable katana: Weapon, + @inject("Weapon") @throwable shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; diff --git a/wiki/factory_injection.md b/wiki/factory_injection.md index 82a901e14..445105ca8 100644 --- a/wiki/factory_injection.md +++ b/wiki/factory_injection.md @@ -3,14 +3,14 @@ Binds an abstraction to a user defined Factory. ```ts @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IFactory") katanaFactory: () => IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Factory") katanaFactory: () => Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katanaFactory(); this._shuriken = shuriken; @@ -23,9 +23,9 @@ class Ninja implements INinja { ``` ```ts -kernel.bind>("IFactory").toFactory((context) => { +kernel.bind>("Factory").toFactory((context: interfaces.Context) => { return () => { - return context.kernel.get("IKatana"); + return context.kernel.get("Katana"); }; }); ``` @@ -33,39 +33,40 @@ kernel.bind>("IFactory").toFactory((context) You can also define a Factory with args: ```ts -kernel.bind>("IFactory").toFactory((context) => { +kernel.bind>("Factory").toFactory((context: interfaces.Context) => { return (throwable: boolean) => { if (throwable) { - return context.kernel.getTagged("IWeapon", "throwable", true); + return context.kernel.getTagged("Weapon", "throwable", true); } else { - return context.kernel.getTagged("IWeapon", "throwable", false); + return context.kernel.getTagged("Weapon", "throwable", false); } }; }); ``` Sometimes you might need to pass arguments to a factory in different moments during the execution: + ```ts -kernel.bind("IEngine").to(PetrolEngine).whenTargetNamed("petrol"); -kernel.bind("IEngine").to(DieselEngine).whenTargetNamed("diesel"); +kernel.bind("Engine").to(PetrolEngine).whenTargetNamed("petrol"); +kernel.bind("Engine").to(DieselEngine).whenTargetNamed("diesel"); -kernel.bind>("IFactory").toFactory((context) => { +kernel.bind>("Factory").toFactory((context) => { return (named: string) => (displacement: number) => { - let engine = context.kernel.getNamed("IEngine", named); + let engine = context.kernel.getNamed("Engine", named); engine.displacement = displacement; return engine; }; }); @injectable() -class DieselCarFactory implements ICarFactory { - private _dieselFactory: (displacement: number) => IEngine ; +class DieselCarFactory implements CarFactory { + private _dieselFactory: (displacement: number) => Engine ; constructor( - @inject("IFactory") factory: (category: string) => (displacement: number) => IEngine + @inject("Factory") factory: (category: string) => (displacement: number) => Engine ) { this._dieselFactory = factory("diesel"); } - public createEngine(displacement: number): IEngine { + public createEngine(displacement: number): Engine { return this._dieselFactory(displacement); } } diff --git a/wiki/get_all_named_tagged.md b/wiki/get_all_named_tagged.md index 6d9e7ae24..c01c49a09 100644 --- a/wiki/get_all_named_tagged.md +++ b/wiki/get_all_named_tagged.md @@ -5,10 +5,10 @@ The InversifyJS kernel provides some helpers to resolve multi-injections. ## Kernel.getAll() ```ts let kernel = new Kernel(); -kernel.bind("IWeapon").to(Katana); -kernel.bind("IWeapon").to(Shuriken); +kernel.bind("Weapon").to(Katana); +kernel.bind("Weapon").to(Shuriken); -let weapons = kernel.getAll("IWeapon"); +let weapons = kernel.getAll("Weapon"); ``` ## Kernel.getNamed() @@ -16,11 +16,11 @@ Named bindings: ```ts let kernel = new Kernel(); -kernel.bind("IWeapon").to(Katana).whenTargetNamed("japonese"); -kernel.bind("IWeapon").to(Shuriken).whenTargetNamed("chinese"); +kernel.bind("Weapon").to(Katana).whenTargetNamed("japonese"); +kernel.bind("Weapon").to(Shuriken).whenTargetNamed("chinese"); -let katana = kernel.getNamed("IWeapon", "japonese"); -let shuriken = kernel.getNamed("IWeapon", "chinese"); +let katana = kernel.getNamed("Weapon", "japonese"); +let shuriken = kernel.getNamed("Weapon", "chinese"); ``` ## Kernel.getTagged() @@ -28,34 +28,34 @@ Tagged bindings: ```ts let kernel = new Kernel(); -kernel.bind("IWeapon").to(Katana).whenTargetTagged("faction", "samurai"); -kernel.bind("IWeapon").to(Shuriken).whenTargetTagged("faction", "ninja"); +kernel.bind("Weapon").to(Katana).whenTargetTagged("faction", "samurai"); +kernel.bind("Weapon").to(Shuriken).whenTargetTagged("faction", "ninja"); -let katana = kernel.getTagged("IWeapon", "faction", "samurai"); -let shuriken = kernel.getTagged("IWeapon", "faction", "ninja"); +let katana = kernel.getTagged("Weapon", "faction", "samurai"); +let shuriken = kernel.getTagged("Weapon", "faction", "ninja"); ``` ## Kernel.isBound() You can use the `isBound` method to check if there are registered bindings for a given service identifier. ```ts -interface IWarrior {} -let warriorId = "IWarrior"; -let warriorSymbol = Symbol("IWarrior"); +interface Warrior {} +let warriorId = "Warrior"; +let warriorSymbol = Symbol("Warrior"); @injectable() -class Ninja implements IWarrior {} +class Ninja implements Warrior {} -interface IKatana {} -let katanaId = "IKatana"; -let katanaSymbol = Symbol("IKatana"); +interface Katana {} +let katanaId = "Katana"; +let katanaSymbol = Symbol("Katana"); @injectable() -class Katana implements IKatana {} +class Katana implements Katana {} let kernel = new Kernel(); -kernel.bind(Ninja).to(Ninja); -kernel.bind(warriorId).to(Ninja); -kernel.bind(warriorSymbol).to(Ninja); +kernel.bind(Ninja).to(Ninja); +kernel.bind(warriorId).to(Ninja); +kernel.bind(warriorSymbol).to(Ninja); kernel.isBound(Ninja)).eql(true); kernel.isBound(warriorId)).eql(true); diff --git a/wiki/inheritance.md b/wiki/inheritance.md index fe6f1d585..c260521dd 100644 --- a/wiki/inheritance.md +++ b/wiki/inheritance.md @@ -1,46 +1,56 @@ # Inheritance + ```ts -interface IWarrior { - weapon: IWeapon; +interface Warrior { + weapon: Weapon; } @injectable() -class Samurai implements IWarrior { +class Samurai implements Warrior { - public weapon: IWeapon; + public weapon: Weapon; - public constructor(weapon: IWeapon) { + public constructor(weapon: Weapon) { this.weapon = weapon; } } ``` + The constructor of a derived class must be manually implemented and annotated. Therefore, the following code snippet: + ```ts @injectable() -class SamuraiMaster extends Samurai implements IWarrior { +class SamuraiMaster extends Samurai implements Warrior { public isMaster: boolean; } ``` + Throws an exception: + ``` Error: Derived class must explicitly declare its constructor: SamuraiMaster ``` + However, he following works: + ```ts @injectable() -class SamuraiMaster extends Samurai implements IWarrior { +class SamuraiMaster extends Samurai implements Warrior { public isMaster: boolean; - public constructor(@inject(SYMBOLS.IWeapon) weapon: IWeapon) { + public constructor(@inject(SYMBOLS.Weapon) weapon: Weapon) { super(weapon); this.isMaster = true; } } ``` -The above also works with `abstract` classes but it has one limitation. It doesn't work when a base class has constructor injections and its derived class don't have any constructor injections: + +The above also works with `abstract` classes but it has one limitation. +It doesn't work when a base class has constructor injections and its derived +class don't have any constructor injections: ```ts @injectable() -class Samurai implements ISamurai { +class Samurai implements Samurai { public rank: string; @@ -50,22 +60,27 @@ class Samurai implements ISamurai { } @injectable() -class SamuraiMaster extends Samurai implements ISamurai { +class SamuraiMaster extends Samurai implements Samurai { constructor() { super("Master"); } } ``` -The precedding code snippet throws an error. Unfortunately, as a result of the technical limitation, this error is misleading: + +The precedding code snippet throws an error. Unfortunately, as a result of +the technical limitation, this error is misleading: + ``` Error: Derived class must explicitly declare its constructor: SamuraiMaster. ``` + You can overcome this limitation by injecting into the derived class: + ```ts kernel.bind(SYMBOLS.RANK).toConstantValue("Master"); @injectable() -class Samurai implements ISamurai { +class Samurai implements Samurai { public rank: string; @@ -75,7 +90,7 @@ class Samurai implements ISamurai { } @injectable() -class SamuraiMaster extends Samurai implements ISamurai { +class SamuraiMaster extends Samurai implements Samurai { constructor(@inject(SYMBOLS.RANK) rank: string) { super(rank); } diff --git a/wiki/kernel_modules.md b/wiki/kernel_modules.md index 59c698864..30d39044d 100644 --- a/wiki/kernel_modules.md +++ b/wiki/kernel_modules.md @@ -1,13 +1,14 @@ # Declaring kernel modules Kernel modules can help you to manage the complexity of your bindings in very large applications. + ```ts -let warriors = new KernelModule((bind: IBind) => { - bind("INinja").to(Ninja); +let warriors = new KernelModule((bind: Bind) => { + bind("Ninja").to(Ninja); }); -let weapons = new KernelModule((bind: IBind) => { - bind("IKatana").to(Katana); - bind("IShuriken").to(Shuriken); +let weapons = new KernelModule((bind: Bind) => { + bind("Katana").to(Katana); + bind("Shuriken").to(Shuriken); }); let kernel = new Kernel(); diff --git a/wiki/kernel_snapshots.md b/wiki/kernel_snapshots.md index d782eb004..bcb54cd74 100644 --- a/wiki/kernel_snapshots.md +++ b/wiki/kernel_snapshots.md @@ -1,8 +1,8 @@ # Kernel snapshots + Declaring kernel snapshots is a feature that helps you to write unit tests with ease: -```ts -/// +```ts import { expect } from "chai"; import * as sinon from "sinon"; @@ -35,9 +35,9 @@ describe("Ninja", () => { hit: () => { return "hit with mock"; } }; - kernel.unbind("IKatana"); - kernel.bind("IKatana").toConstantValue(katanaMock); - let ninja = kernel.get("INinja"); + kernel.unbind("Katana"); + kernel.bind("Katana").toConstantValue(katanaMock); + let ninja = kernel.get("Ninja"); expect(ninja.fight()).eql("hit with mock"); }); @@ -48,9 +48,9 @@ describe("Ninja", () => { throw: () => { return "hit with mock"; } }; - kernel.unbind("IShuriken"); - kernel.bind("IShuriken").toConstantValue(shurikenMock); - let ninja = kernel.get("IShuriken"); + kernel.unbind("Shuriken"); + kernel.bind("Shuriken").toConstantValue(shurikenMock); + let ninja = kernel.get("Shuriken"); expect(ninja.sneak()).eql("hit with mock"); }); diff --git a/wiki/middleware.md b/wiki/middleware.md index 187aa9d2e..abff55733 100644 --- a/wiki/middleware.md +++ b/wiki/middleware.md @@ -17,6 +17,7 @@ Middleware can be used to implement powerful development tools. This kind of too to identify problems during the development process. ## Basic middleware + ```ts function logger(planAndResolve: PlanAndResolve): PlanAndResolve { return (args: PlanAndResolveArgs) => { @@ -35,13 +36,13 @@ Now that we have declared a middleware we can create a new Kernel and use its ap method to apply it: ```ts -interface INinja {} +interface Ninja {} @injectable() -class Ninja implements INinja {} +class Ninja implements Ninja {} let kernel = new Kernel(); -kernel.bind("INinja").to(Ninja); +kernel.bind("Ninja").to(Ninja); kernel.applyMiddleware(logger); ``` @@ -49,23 +50,28 @@ kernel.applyMiddleware(logger); The logger middleware will log in console the execution time: ```ts -let ninja = kernel.get("INinja"); +let ninja = kernel.get("Ninja"); > 21 ``` ## Multiple middleware functions + When multiple middleware functions are applied: + ```ts kernel.applyMiddleware(middleware1, middleware2); ``` + The middleware will be invoked from right to leaft. This means that `middleware2` is invoked before `middleware1`. ## Context interceptor + In some cases you may want to intercept the resolution plan. The default `contextInterceptor` is passed to the middleware as an property of `args`. + ```ts function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { return (args: PlanAndResolveArgs) => { @@ -74,12 +80,14 @@ function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { }; } ``` + You can extends the default `contextInterceptor` using a function: + ```ts function middleware1(planAndResolve: PlanAndResolve): PlanAndResolve { return (args: PlanAndResolveArgs) => { let nextContextInterceptor = args.contextInterceptor; - args.contextInterceptor = (context: IContext) => { + args.contextInterceptor = (context: interfaces.Context) => { console.log(context); return nextContextInterceptor(context); }; diff --git a/wiki/multi_injection.md b/wiki/multi_injection.md index 9c02acef0..854e64901 100644 --- a/wiki/multi_injection.md +++ b/wiki/multi_injection.md @@ -1,32 +1,34 @@ # Multi-injection + We can use multi-injection When two or more concretions have been bound to the an abstraction. -Notice how an array of `IWeapon` is injected into the `Ninja` class via its constructor thanks to the usage of the `@multiInject` decorator: +Notice how an array of `Weapon` is injected into the `Ninja` class via its constructor thanks to the usage of the `@multiInject` decorator: + ```ts -interface IWeapon { +interface Weapon { name: string; } @injectable() -class Katana implements IWeapon { +class Katana implements Weapon { public name = "Katana"; } @injectable() -class Shuriken implements IWeapon { +class Shuriken implements Weapon { public name = "Shuriken"; } -interface INinja { - katana: IWeapon; - shuriken: IWeapon; +interface Ninja { + katana: Weapon; + shuriken: Weapon; } @injectable() -class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; +class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @multiInject("IWeapon") weapons: IWeapon[] + @multiInject("Weapon") weapons: Weapon[] ) { this.katana = weapons[0]; this.shuriken = weapons[1]; @@ -34,10 +36,10 @@ class Ninja implements INinja { } ``` -We are binding `Katana` and `Shuriken` to `IWeapon`: +We are binding `Katana` and `Shuriken` to `Weapon`: ```ts -kernel.bind("INinja").to(Ninja); -kernel.bind("IWeapon").to(Katana); -kernel.bind("IWeapon").to(Shuriken); +kernel.bind("Ninja").to(Ninja); +kernel.bind("Weapon").to(Katana); +kernel.bind("Weapon").to(Shuriken); ``` diff --git a/wiki/named_bindings.md b/wiki/named_bindings.md index 628ee04b3..ad59e5638 100644 --- a/wiki/named_bindings.md +++ b/wiki/named_bindings.md @@ -2,27 +2,28 @@ We can use named bindings to fix `AMBIGUOUS_MATCH` errors when two or more concretions have been bound to the an abstraction. Notice how the constructor arguments of the `Ninja` class have been annotated using the `@named` decorator: + ```ts -interface IWeapon {} +interface Weapon {} @injectable() -class Katana implements IWeapon {} +class Katana implements Weapon {} @injectable() -class Shuriken implements IWeapon {} +class Shuriken implements Weapon {} -interface INinja { - katana: IWeapon; - shuriken: IWeapon; +interface Ninja { + katana: Weapon; + shuriken: Weapon; } @injectable() -class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; +class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @named("strong")katana: IWeapon, - @inject("IWeapon") @named("weak") shuriken: IWeapon + @inject("Weapon") @named("strong")katana: Weapon, + @inject("Weapon") @named("weak") shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -30,11 +31,11 @@ class Ninja implements INinja { } ``` -We are binding `Katana` and `Shuriken` to `IWeapon` but a `whenTargetNamed` constraint is +We are binding `Katana` and `Shuriken` to `Weapon` but a `whenTargetNamed` constraint is added to avoid `AMBIGUOUS_MATCH` errors: ```ts -kernel.bind("INinja").to(Ninja); -kernel.bind("IWeapon").to(Katana).whenTargetNamed("strong"); -kernel.bind("IWeapon").to(Shuriken).whenTargetNamed("weak"); +kernel.bind("Ninja").to(Ninja); +kernel.bind("Weapon").to(Katana).whenTargetNamed("strong"); +kernel.bind("Weapon").to(Shuriken).whenTargetNamed("weak"); ``` diff --git a/wiki/oo_design.md b/wiki/oo_design.md index 25bc00d05..03197f942 100644 --- a/wiki/oo_design.md +++ b/wiki/oo_design.md @@ -1,7 +1,12 @@ # Object-oriented design -InversifyJS is an IoC container, an IoC container is a tool that helps you to write Object-oriented code that is easy to modify and extend over time. However, an IoC container can be wrongly used. To use an IoC in a correct manner you you must follow some basic object-oriented programming principles like the [SOLID principles](https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)). +InversifyJS is an IoC container, an IoC container is a tool that helps you +to write Object-oriented code that is easy to modify and extend over time. +However, an IoC container can be wrongly used. To use an IoC in a correct +manner you you must follow some basic object-oriented programming principles +like the [SOLID principles](https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)). -This page of the wiki will focus on the Dependency Inversion Principle (one of the SOLID principles) and the Composite Reuse Principle. +This page of the wiki will focus on the Dependency Inversion Principle (one of +the SOLID principles) and the Composite Reuse Principle. ### The Composite Reuse Principle @@ -10,7 +15,8 @@ This page of the wiki will focus on the Dependency Inversion Principle (one of t Using inheritance is OK but we should use composition instead if possible. More than one level of inheritance is probably a [code smell](https://en.wikipedia.org/wiki/Code_smell). -Inheritance is a bad thing because it is the strongest kind of coupling between modules. Let's see an example: +Inheritance is a bad thing because it is the strongest kind of coupling +between modules. Let's see an example: ```ts import BaseModel from "someframework"; @@ -38,8 +44,8 @@ The following example do something similar but it favors 'object composition' ov ```ts @injectable() class DerivedModel extends BaseModel { - public baseModel: IBaseModel; - public constructor(@inject("IBaseModel") baseModel: IBaseModel) { + public baseModel: BaseModel; + public constructor(@inject("BaseModel") baseModel: BaseModel) { this.baseModel = baseModel; } public saveOrUpdate() { @@ -76,23 +82,25 @@ class Ninja { } ``` + In this case the Ninja class has a dependency on the Katana class: ```ts Ninja --> Katana ``` + Notice how the arrow that ilustrate the dependency goes from left to right. -If we update the ninja class to dependen upon an abstraction of the Katana class (the IKatana interface): +If we update the ninja class to dependen upon an abstraction of the Katana class (the Katana interface): ```ts @injectable() class Ninja { - private _katana: IKatana; + private _katana: Katana; public constructor( - inject("IKatana") katana: IKatana + inject("Katana") katana: Katana ) { this._katana = katana; } @@ -102,17 +110,17 @@ class Ninja { } ``` -In this case, both the Ninja class and the Katana class have a dependency on the IKatana interface: +In this case, both the Ninja class and the Katana class have a dependency on the Katana interface: ```ts -Ninja --> IKatana -Katana --> IKatana +Ninja --> Katana +Katana --> Katana ``` This can also be represented as: ```ts -Ninja --> IKatana <-- Katana +Ninja --> Katana <-- Katana ``` Have you notice how one of the arrows is now inverted? diff --git a/wiki/property_injection.md b/wiki/property_injection.md index a3de73cfb..d0cd00957 100644 --- a/wiki/property_injection.md +++ b/wiki/property_injection.md @@ -4,13 +4,13 @@ InversifyJS supports property injection because sometimes constructor injection let kernel = new Kernel(); let inject = makePropertyInjectDecorator(kernel); -interface ISomeService { +interface SomeService { count: number; increment(): void; } @injectable() -class SomeService implements ISomeService { +class SomeService implements SomeService { public count: number; public constructor() { this.count = 0; @@ -21,8 +21,8 @@ class SomeService implements ISomeService { } class SomeWebComponent { - @inject("ISomeService") - private _service: ISomeService; + @inject("SomeService") + private _service: SomeService; public doSomething() { let count = this._service.count; this._service.increment(); @@ -30,7 +30,7 @@ class SomeWebComponent { } } -kernel.bind("ISomeService").to(SomeService); +kernel.bind("SomeService").to(SomeService); let someComponent = new SomeWebComponent(); expect(someComponent.doSomething()).eql(0); @@ -51,25 +51,25 @@ The `propertyIsEnumerable` function returns `false` for properties that return ` ```ts class Warrior { - @injectNamed(TYPES.IWeapon, "not-throwwable") + @injectNamed(TYPES.Weapon, "not-throwwable") @named("not-throwwable") - public primaryWeapon: IWeapon; + public primaryWeapon: Weapon; - @injectNamed(TYPES.IWeapon, "throwwable") + @injectNamed(TYPES.Weapon, "throwwable") @named("throwwable") - public secondaryWeapon: IWeapon; + public secondaryWeapon: Weapon; } class Warrior { - @injectTagged(TYPES.IWeapon, "throwwable", false) + @injectTagged(TYPES.Weapon, "throwwable", false) @tagged("throwwable", false) - public primaryWeapon: IWeapon; + public primaryWeapon: Weapon; - @injectTagged(TYPES.IWeapon, "throwwable", true) + @injectTagged(TYPES.Weapon, "throwwable", true) @tagged("throwwable", true) - public secondaryWeapon: IWeapon; + public secondaryWeapon: Weapon; } ``` @@ -79,15 +79,15 @@ class Warrior { let kernel = new Kernel(); let multiInject = makePropertyMultiInjectDecorator(kernel); -let TYPES = { IWeapon: "IWeapon" }; +let TYPES = { Weapon: "Weapon" }; -interface IWeapon { +interface Weapon { durability: number; use(): void; } @injectable() -class Sword implements IWeapon { +class Sword implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -98,7 +98,7 @@ class Sword implements IWeapon { } @injectable() -class WarHammer implements IWeapon { +class WarHammer implements Weapon { public durability: number; public constructor() { this.durability = 100; @@ -109,12 +109,12 @@ class WarHammer implements IWeapon { } class Warrior { - @multiInject(TYPES.IWeapon) - public weapons: IWeapon[]; + @multiInject(TYPES.Weapon) + public weapons: Weapon[]; } -kernel.bind(TYPES.IWeapon).to(Sword); -kernel.bind(TYPES.IWeapon).to(WarHammer); +kernel.bind(TYPES.Weapon).to(Sword); +kernel.bind(TYPES.Weapon).to(WarHammer); let warrior1 = new Warrior(); diff --git a/wiki/provider_injection.md b/wiki/provider_injection.md index 560d5031e..6785dac0f 100644 --- a/wiki/provider_injection.md +++ b/wiki/provider_injection.md @@ -1,16 +1,18 @@ # Injecting a Provider (asynchronous Factory) + Binds an abstraction to a Provider. A provider is an asynchronous factory, this is useful when dealing with asynchronous I/O operations. + ```ts @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - public katana: IKatana; - public shuriken: IShuriken; - public katanaProvider: IProvider; + public katana: Katana; + public shuriken: Shuriken; + public katanaProvider: Provider; public constructor( - @inject("IProvider") katanaProvider: IProvider, - @inject("IShuriken") shuriken: IShuriken + @inject("Provider") katanaProvider: Provider, + @inject("Shuriken") shuriken: Shuriken ) { this.katanaProvider = katanaProvider; this.katana= null; @@ -24,16 +26,16 @@ class Ninja implements INinja { ``` ```ts -kernel.bind>("IProvider").toProvider((context) => { +kernel.bind>("Provider").toProvider((context) => { return () => { - return new Promise((resolve) => { - let katana = context.kernel.get("IKatana"); + return new Promise((resolve) => { + let katana = context.kernel.get("Katana"); resolve(katana); }); }; }); -var ninja = kernel.get("INinja"); +var ninja = kernel.get("Ninja"); ninja.katanaProvider() .then((katana) => { ninja.katana = katana; }) diff --git a/wiki/purpose.md b/wiki/purpose.md index b1fc07617..5da846234 100644 --- a/wiki/purpose.md +++ b/wiki/purpose.md @@ -16,22 +16,20 @@ InversifyJS solves these problems: - There are no namespace collisions thanks to tagged, named and contextual bindings. - It is a stand alone library. - - InversifyJS offers you real decoupling. Consider the following class: ``` import TYPES from "./constants/types"; @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject(TYPES.IKatana) katana: IKatana, - @inject(TYPES.IShuriken) shuriken: IShuriken + @inject(TYPES.Katana) katana: Katana, + @inject(TYPES.Shuriken) shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -42,11 +40,12 @@ class Ninja implements INinja { } ``` + ``` let TYPES = { - INinja: Symbol("INinja"), - IKatana: Symbol("IKatana"), - IShuriken: Symbol("IShuriken") + Ninja: Symbol("Ninja"), + Katana: Symbol("Katana"), + Shuriken: Symbol("Shuriken") }; export default TYPES; @@ -68,9 +67,9 @@ that contains the application source code: import Shuriken from "./entitites/shuriken"; import Ninja from "./entitites/ninja"; - kernel.bind(TYPES.IKATANA).to(Katana); - kernel.bind(TYPES.ISHURIKEN).to(Shuriken); - kernel.bind(TYPES.ININJA).to(Ninja); + kernel.bind(TYPES.KATANA).to(Katana); + kernel.bind(TYPES.SHURIKEN).to(Shuriken); + kernel.bind(TYPES.NINJA).to(Ninja); This means that all the coupling in your application takes place in one unique place: the `inversify.config.ts` file. This is really important and we are going to prove it with an example. @@ -80,9 +79,9 @@ We just need to go to the `inversify.config.ts` and change the Katana binding: import Katana from "./entitites/SharpKatana"; if(difficulty === "hard") { - kernel.bind(TYPES.IKATANA).to(SharpKatana); + kernel.bind(TYPES.KATANA).to(SharpKatana); } else { - kernel.bind(TYPES.IKATANA).to(Katana); + kernel.bind(TYPES.KATANA).to(Katana); } You don't need to change the Ninja file! @@ -103,14 +102,4 @@ We also have plans for the development of dev-tools like browser extensions and ### 3. Type safety The library has been developed using TypeScript so type safety comes out of the box if you work with TypeScript but it is nice to mention that if you try to inject a Katana into a class that -expects an implementation of IShuriken you will get a compilation error. - -# Articles -I wrote a few articles in defense of IoC containers in JavaScript that explain the preceding with much more details: -- [The current state of dependency inversion in JavaScript](http://blog.wolksoftware.com/the-current-state-of-dependency-inversion-in-javascript) -- [About object-oriented design and the “class” & “extends” keywords in TypeScript / ES6](http://blog.wolksoftware.com/about-classes-inheritance-and-object-oriented-design-in-typescript-and-es6) -- [Introducing InversifyJS 2.0](http://blog.wolksoftware.com/introducing-inversify-2) -- [Introducing InversifyJS](http://blog.wolksoftware.com/introducing-inversifyjs) - - - +expects an implementation of `Shuriken` you will get a compilation error. diff --git a/wiki/recipes.md b/wiki/recipes.md index 57839a39e..e7f48c734 100644 --- a/wiki/recipes.md +++ b/wiki/recipes.md @@ -66,28 +66,33 @@ testFunc(); // > Injected! 1 // > Injected! 2 ``` + ## Overriding bindings on unit tests + Sometimes you want to use your binding declarations in your unit test but you need to override some of them. We recommend you to declare your bindings as kernel modules inside your application: + ```ts -let warriors: IKernelModule = (k: IKernel) => { - k.bind("INinja").to(Ninja); -}; +let warriors = new KernelModule((bind: Bind) => { + bind("Ninja").to(Ninja); +}); -let weapons: IKernelModule = (k: IKernel) => { - k.bind("IKatana").to(Katana).inTransientScope(); - k.bind("IShuriken").to(Shuriken).inSingletonScope(); -}; +let weapons = new KernelModule((bind: Bind) => { + bind("Katana").to(Katana); + bind("Shuriken").to(Shuriken); +}); export { warriors, weapons }; ``` + You will then be able to create a new kernel using the bindings from your application: + ```ts import { warriors, weapons} from './shared/kernel_modules'; import { Kernel } from "inversify"; describe("something", () => { - let kernel: inversify.IKernel; + let kernel: inversify.Kernel; beforeEach(() => { kernel = new Kernel(); @@ -106,4 +111,5 @@ describe("something", () => { }); ``` + As you can see you can then override specific bindings in each test case. diff --git a/wiki/scope.md b/wiki/scope.md index a0e0d12fb..9522881b2 100644 --- a/wiki/scope.md +++ b/wiki/scope.md @@ -1,7 +1,8 @@ # Controlling the scope of the dependencies InversifyJS uses transient scope by default but you can also use singleton scope: + ```ts -kernel.bind("IShuriken").to(Shuriken).inTransientScope(); // Default -kernel.bind("IShuriken").to(Shuriken).inSingletonScope(); +kernel.bind("Shuriken").to(Shuriken).inTransientScope(); // Default +kernel.bind("Shuriken").to(Shuriken).inSingletonScope(); ``` diff --git a/wiki/symbols_as_id.md b/wiki/symbols_as_id.md index a56388b0e..e854d48dd 100644 --- a/wiki/symbols_as_id.md +++ b/wiki/symbols_as_id.md @@ -7,34 +7,34 @@ In very large applications using strings as the identifiers of the types to be i import { Kernel, injectable, inject } from "inversify"; let Symbols = { - INinja : Symbol("INinja"), - IKatana : Symbol("IKatana"), - IShuriken : Symbol("IShuriken") + Ninja : Symbol("Ninja"), + Katana : Symbol("Katana"), + Shuriken : Symbol("Shuriken") }; @injectable() -class Katana implements IKatana { +class Katana implements Katana { public hit() { return "cut!"; } } @injectable() -class Shuriken implements IShuriken { +class Shuriken implements Shuriken { public throw() { return "hit!"; } } @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject(Symbols.IKatana) katana: IKatana, - @inject(Symbols.IShuriken) shuriken: IShuriken + @inject(Symbols.Katana) katana: Katana, + @inject(Symbols.Shuriken) shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; @@ -46,7 +46,7 @@ class Ninja implements INinja { } var kernel = new Kernel(); -kernel.bind(Symbols.INinja).to(Ninja); -kernel.bind(Symbols.IKatana).to(Katana); -kernel.bind(Symbols.IShuriken).to(Shuriken); +kernel.bind(Symbols.Ninja).to(Ninja); +kernel.bind(Symbols.Katana).to(Katana); +kernel.bind(Symbols.Shuriken).to(Shuriken); ``` diff --git a/wiki/tagged_bindings.md b/wiki/tagged_bindings.md index 42c370e3d..637cd358e 100644 --- a/wiki/tagged_bindings.md +++ b/wiki/tagged_bindings.md @@ -1,28 +1,30 @@ # Tagged bindings + We can use tagged bindings to fix `AMBIGUOUS_MATCH` errors when two or more concretions have been bound to the an abstraction. Notice how the constructor arguments of the `Ninja` class have been annotated using the `@tagged` decorator: + ```ts -interface IWeapon {} +interface Weapon {} @injectable() -class Katana implements IWeapon {} +class Katana implements Weapon {} @injectable() -class Shuriken implements IWeapon {} +class Shuriken implements Weapon {} -interface INinja { - katana: IWeapon; - shuriken: IWeapon; +interface Ninja { + katana: Weapon; + shuriken: Weapon; } @injectable() -class Ninja implements INinja { - public katana: IWeapon; - public shuriken: IWeapon; +class Ninja implements Ninja { + public katana: Weapon; + public shuriken: Weapon; public constructor( - @inject("IWeapon") @tagged("canThrow", false) katana: IWeapon, - @inject("IWeapon") @tagged("canThrow", true) shuriken: IWeapon + @inject("Weapon") @tagged("canThrow", false) katana: Weapon, + @inject("Weapon") @tagged("canThrow", true) shuriken: Weapon ) { this.katana = katana; this.shuriken = shuriken; @@ -30,11 +32,11 @@ class Ninja implements INinja { } ``` -We are binding `Katana` and `Shuriken` to `IWeapon` but a `whenTargetTagged` +We are binding `Katana` and `Shuriken` to `Weapon` but a `whenTargetTagged` constraint is added to avoid `AMBIGUOUS_MATCH` errors: ```ts -kernel.bind(ninjaId).to(Ninja); -kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); -kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); +kernel.bind(ninjaId).to(Ninja); +kernel.bind(weaponId).to(Katana).whenTargetTagged("canThrow", false); +kernel.bind(weaponId).to(Shuriken).whenTargetTagged("canThrow", true); ``` diff --git a/wiki/upgrade.md b/wiki/upgrade.md index 61be56339..94e35a6b5 100644 --- a/wiki/upgrade.md +++ b/wiki/upgrade.md @@ -11,27 +11,36 @@ The 1.x `BindingScopeEnum` is named `BindingScope` in 2.x ### Fluent binding syntax The 1.x binding syntax looks as follows: + ```ts kernel.bind(new TypeBinding("FooInterface", Foo, BindingScopeEnum.Transient)); ``` + The 2.x binding syntax looks as follows: + ```ts kernel.bind("FooInterface").to(Foo).inTransientScope() ``` + ### Resolution syntax + The 1.x `kernel.resolve(identifier: string)` method is now `kernel.get(identifier: string)` 2.x. The 1.x resolution syntax looks as follows: + ```ts var foobar = kernel.resolve("FooBarInterface"); ``` + The 2.x resolution syntax looks as follows: + ```ts var foobar = kernel.get("FooBarInterface"); ``` ### @injectable & @inject All your classes must be decorated with the `@injectable()` decorator. If your class has a dependency in a class that's enough: + ```ts @injectable() class Katana { @@ -48,7 +57,7 @@ class Shuriken { } @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { private _katana: Katana; private _shuriken: Shuriken; @@ -67,16 +76,17 @@ class Ninja implements INinja { } ``` But if your class has a dependency on an interface you will also need to use the `@inject` decorator. + ```ts @injectable() -class Ninja implements INinja { +class Ninja implements Ninja { - private _katana: IKatana; - private _shuriken: IShuriken; + private _katana: Katana; + private _shuriken: Shuriken; public constructor( - @inject("IKatana") katana: IKatana, - @inject("IShuriken") shuriken: IShuriken + @inject("Katana") katana: Katana, + @inject("Shuriken") shuriken: Shuriken ) { this._katana = katana; this._shuriken = shuriken; diff --git a/wiki/value_injection.md b/wiki/value_injection.md index 7b6b0b5f7..4bc76a597 100644 --- a/wiki/value_injection.md +++ b/wiki/value_injection.md @@ -1,9 +1,9 @@ # Injecting a constant or dynamic value Binds an abstraction to a constant value: ```ts -kernel.bind("IKatana").toConstantValue(new Katana()); +kernel.bind("Katana").toConstantValue(new Katana()); ``` Binds an abstraction to a dynamic value: ```ts -kernel.bind("IKatana").toDynamicValue(() => { return new Katana(); }); +kernel.bind("Katana").toDynamicValue(() => { return new Katana(); }); ```