JavaScript dependency injection implementation

Author: tshemsedinov

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+*.log
+.DS_Store

JavaScript/README.md

@@ -0,0 +1,67 @@
+## Pependency Injection
+
+Purpose: learn how to create sandboxed context for modues to separate them and
+minimize cross-modules code coupling, extracting at least two abstraction layers
+(applied and system) and how to execute applied code in virtual environment,
+changing its behavior using IoC from system layer.
+
+## Files
+
+* `framework.js` - small piece of the framework, just to demonstrate IoC
+* `application.js` - small piece of the application, also for IoC demonstration
+
+## How to execute
+
+From the command line, type: `node ./framework.js` or `node framework`
+
+## Tasks
+
+You may select at least one of the following tasks, make a fork of this
+repository and implement your solution there. If those tasks are simple
+for somebody, please see additional tasks below.
+
+1. Add `setTimeout` and `setInterval` to the application context and use them
+printing something from the timer function using `console.log()`
+
+2. Inject a link to `util` library into the application context and make a few
+calls to its functions from applied code
+
+3. Implement the ability to run different applications inside framework, using
+command line option, e.g.: `node framework <applicationName>`
+
+4. Wrap or intercept `console.log()` call to add more info into console output
+in the following format: `<applicationName> <time> <message>`
+
+5. Wrap or intercept `console.log()` in the sandboxed application logging all
+console output into a file in the format: `<applicationName> <time> <message>`
+
+6. Give a link to `require` function to the application, add call to it and
+wrap it for logging to a file in the format: `<time> <module name>` 
+
+7. Export a hash from `application.js` with multiple functions and variables,
+print the list with types from framework
+
+8. Export a function from `application.js` and print its parameter count and
+source code from the framework
+
+9. Print a list of everything from the application global context (application
+sandbox) with the data types specified
+
+10. Compare an application sandboxed context keys before application loaded and
+after, print it from the framework and find a difference (keys added / deleted)
+
+## Additional tasks
+
+11. You can combine several tasks (listed above) in your code, implement a more
+complex example of interaction between framework and application, preparing
+run-time environment (sandbox) and/or improving CLI (command line interface)
+
+12. Implement a similar example in another programming language
+
+13. Improve and/or optimize Impress Application Server code, specifically
+everything related to sandboxing, see:
+[/lib/impress.application.js](https://github.com/tshemsedinov/impress/blob/master/lib/impress.application.js)
+
+14. Use IoC and code isolation principles using sandboxed context and/or other
+similar technique in your projects (any technological stack) to demonstrate its
+use and the effect of such use

JavaScript/application.js

@@ -0,0 +1,13 @@
+'use strict';
+
+// File contains a small piece of the source to demonstrate main module
+// of a sample application to be executed in the sandboxed context by
+// another pice of code from `framework.js`. Read README.md for tasks.
+
+// Print from the global context of application module
+console.log('From application global context');
+
+module.exports = function() {
+  // Print from the exported function context
+  console.log('From application exported function');
+};

JavaScript/framework.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// Example showing us how the framework creates an environment (sandbox) for
+// appication runtime, load an application code and passes a sandbox into app
+// as a global context and receives exported application interface
+
+// The framework can require core libraries
+global.api = {};
+api.fs = require('fs');
+api.vm = require('vm');
+
+// Create a hash and turn it into the sandboxed context which will be
+// the global context of an application
+let context = { module: {}, console: console };
+context.global = context;
+let sandbox = api.vm.createContext(context);
+
+// Read an application source code from the file
+let fileName = './application.js';
+api.fs.readFile(fileName, (err, src) => {
+  // We need to handle errors here
+
+  // Run an application in sandboxed context
+  let script = api.vm.createScript(src, fileName);
+  script.runInNewContext(sandbox);
+
+  // We can access a link to exported interface from sandbox.module.exports
+  // to execute, save to the cache, print to console, etc.
+});

README.md

@@ -1,2 +1,2 @@
-# DependencyInjection
+# Dependency Injection
 Resolving dependencies with dependency injection