worker injection

README.md

@@ -5,21 +5,90 @@ Skyrocket
 [![Build Status](https://travis-ci.org/runspired/skyrocket.svg)](https://travis-ci.org/runspired/skyrocket)
 [![Ember Observer Score](http://emberobserver.com/badges/skyrocket.svg)](http://emberobserver.com/addons/skyrocket)
 
-Skyrocket is an attempt to eliminate the friction of building and using Workers,
-unlocking applications that consistently function at 60fps even in the most advanced
-use cases in hostile environments.  [Read More](./OVERVIEW.md)
-
-- [Terminology Guide](./Terminology.md)
-
+Skyrocket enables you to build multi-threaded applications, helping you create apps
+ that consistently function at 60fps even in the most advanced use cases in hostile environments.
 
 ## Installation
 
 `ember install skyrocket-engine`
 
 
-## Usage
+### Scaffold A Worker
+
+```cli
+ember g worker <worker-name>
+```
+
+Produces the following:
+```cli
+  /app/workers/<worker-name>/
+     contract.js
+     worker.js
+```
+
+When building or serving your ember application, `<worker-name>/worker.js` will be built as
+as stand alone file located at `/assets/workers/<worker-name>.js`, while
+`<worker-name>/contract.js` will be loaded into your app.
+
+### Imports
+
+Your worker can take full advantage of `es6` imports.
+
+### Restrictions
+
+Workers are workers, if a module does something that uses a browser API
+that's not available in a worker, it will error. In the near future, 
+you will be able to import environment stubs to provide your worker needed
+ browser shims as well.
+
+
+## Creating Your First Worker
+
+### The Contract
+
+The contract is a "model" of your Worker's exposed API.  It represents the
+asynchronous methods, events, and properties (called snapshots) which will be available
+to your app.
+
+```js
+import { Contract, Primitives:p } from 'skyrocket';
+
+export default Interface.extend({
+  foo: p.snapshot(),
+  bar: p.method(),
+  baz: p.event({ outbound: false }), // specify an inbound (to the main thread) only event
+  spam: p.event({ inbound: false }) // specify an outbound (to the worked) only event
+});
+```
+
+### The worker
+
+The Worker is the stand alone mini-application that will be created when an Interface is instantiated.
+It should implement the primitives that the Interface defines.
+
+```js
+import { Worker } from 'skyrocket';
+import api from './interface';
+
+export default Worker.extend({
+  'interface': api,
+
+  // foo is a property, but also a snapshot.
+  // whenever foo updates, it's new state will
+  // be updated on the app
+  foo: 'hello world',
+
+  // bar can be invoked from app
+  // it's return can be a value or a promise
+  bar() {
+    this.send('baz', {}); // send the baz event to the app
+  },
+  onSpam: on('spam', function() {}) // do something when the worker receives the spam event
+});
+```
+
 
-<coming soon> See the [Overview](./OVERVIEW.md) for detailed implementation details.
+## Using Your Worker
 
 
 ## Fastboot

addon/-private/-worker-injection-fill.js

@@ -0,0 +1,40 @@
+import Ember from 'ember';
+import getOwner from 'ember-getowner-polyfill';
+
+const {
+  inject,
+  computed
+  } = Ember;
+
+function lazyInjectWorker(name) {
+  let [worker, label] = name.split(':');
+
+  const fn = function lookupWorkerInstance() {
+    let owner = getOwner(this);
+
+    if (label) {
+      let instanceName = `worker-instance:${worker}--${label}`;
+      let instance = owner.lookup(instanceName);
+
+      if (!instance) {
+        let factory = owner._lookupFactory(`worker:${worker}`);
+
+        instance = factory.create({
+          label
+        });
+
+        owner.register(instanceName, instance);
+      }
+
+      return instance;
+    }
+
+    return owner.lookup(worker);
+  };
+
+  return computed(fn);
+}
+
+inject.worker = lazyInjectWorker;
+
+export default lazyInjectWorker;

addon/-private/-worker-service.js

@@ -0,0 +1,16 @@
+/*
+ * WorkerService
+ *
+ *
+ *
+ * @private
+ */
+import Ember from 'ember';
+
+const {
+  Object: Obj
+  } = Ember;
+
+export default Obj.extend({
+
+});

addon/-private/-worker-shell.js

@@ -0,0 +1,26 @@
+import Transport from './-worker-transport';
+
+const OWNER = Symbol('-worker-owner');
+
+export default class WorkerShell {
+
+  constructor(options) {
+    this.transport = new Transport({
+      isWorker: true
+    });
+
+    this.instance = options.worker.create({
+      [OWNER]: this
+    });
+
+    this.contract = options.contract.create({
+      transport: this.transport,
+      instance: this.instance
+    });
+  }
+
+  static create(options) {
+    return new WorkerShell(options);
+  }
+
+}

addon/-private/-worker-transport.js

@@ -0,0 +1,77 @@
+import Global from './utils/global';
+
+const SYSTEM_TYPE = '-worker';
+let REQUEST_INC = 0;
+
+export default class Transport {
+
+  constructor(src, options) {
+    this.src = src || Global;
+    this.isMaster = !!src;
+    this.isWorker = !src;
+    this.options = options;
+
+    this.callbacks = new WeakMap();
+
+    this.connect();
+  }
+
+  _idFor(request) {
+    if (!request.__rid) {
+      request.__rid = `${this.isWorker ? 'W' : 'M'}:${SYSTEM_TYPE}-${Date.now()}-${REQUEST_INC++}`;
+    }
+    return request.__rid;
+  }
+
+  connect() {
+    // send ping
+    this.src.addEventListener('message', (...args) => {
+      this._receive(...args);
+    });
+  }
+
+  registerEvent() {}
+
+  registerTask() {}
+
+
+
+
+
+
+
+
+  send() {
+    this._send({
+
+    });
+  }
+
+  sendWithCallback(...args) {
+    let cb = args.pop();
+    let req = {
+      data: args
+    };
+    let id = this._idFor(req);
+
+    this._registerCallback(id, cb);
+    this._send(req);
+  }
+
+  _send() {
+    this.src.postMessage(...arguments);
+  }
+
+  _receive(event) {
+
+  }
+
+  _registerCallback(id, callback) {
+    this.callbacks.set(id, {
+      id,
+      callback,
+      startTime: Date.now()
+    });
+  }
+
+}

addon/-private/object/index.js

@@ -0,0 +1,8 @@
+/*
+  We don't want to use Ember.Object long term,
+  but this is the easiest way to get this running
+  at the moment.
+ */
+import Ember from 'ember';
+
+export default Ember.Object;

addon/-private/utils/global.js

@@ -0,0 +1,6 @@
+/* global global, self, window */
+const GLOBAL_ENV = typeof self !== 'undefined' ? self :
+  (typeof global !== 'undefined' ? global :
+    (typeof window !== 'undefined' ? window : false));
+
+export default GLOBAL_ENV;

addon/index.js

@@ -1,18 +1,17 @@
-import Ember from 'ember';
-import Interface from './lib/interface';
+import Contract from './lib/contract';
 import Worker from './lib/worker';
-import Primitives from './lib/primitives/index';
+import Primitives from 'primitives/index';
 
 export {
-  Interface,
-  Worker,
-  Primitives
+  Contract,
+  Primitives,
+  Worker
 };
 
 const Skyrocket = {
-  Interface,
-  Worker,
-  Primitives
+  Contract,
+  Primitives,
+  Worker
 };
 
 export default Skyrocket;

addon/lib/contract.js

@@ -0,0 +1,5 @@
+import SkyrocketObject from '../-private/object/index';
+
+export default SkyrocketObject.extend({
+  _isContractFactory: true
+});