Start re-organizing things in terms of modules

Rakefile

@@ -3,6 +3,26 @@ require "js_module_transpiler"
 
 directory "browser"
 directory "node"
+directory "tmp"
+
+file "tmp/rsvp.js" => ["lib/loader.js", "lib/async.js", "lib/events.js", "lib/rsvp.js"] do
+  loader = File.read("lib/loader.js")
+  async = File.read("lib/async.js")
+  events = File.read("lib/events.js")
+  rsvp = File.read("lib/rsvp.js")
+
+  output = [
+    loader,
+    async,
+    events,
+    rsvp,
+    "export RSVP"
+  ]
+
+  File.open("tmp/rsvp.js", "w") do |file|
+    file.puts output.join("\n")
+  end
+end
 
 file "browser/rsvp.js" => ["browser", "lib/rsvp.js"] do
   library = File.read("lib/rsvp.js")

lib/async.js

+var browserGlobal = (typeof window !== 'undefined') ? window : {};
+
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var config;
+
+if (typeof process !== 'undefined' &&
+  {}.toString.call(process) === '[object process]') {
+  config.async = function(callback, binding) {
+    process.nextTick(function() {
+      callback.call(binding);
+    });
+  };
+} else if (BrowserMutationObserver) {
+  var queue = [];
+
+  var observer = new BrowserMutationObserver(function() {
+    var toProcess = queue.slice();
+    queue = [];
+
+    toProcess.forEach(function(tuple) {
+      var callback = tuple[0], binding = tuple[1];
+      callback.call(binding);
+    });
+  });
+
+  var element = document.createElement('div');
+  observer.observe(element, { attributes: true });
+
+  // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
+  window.addEventListener('unload', function(){
+    observer.disconnect();
+    observer = null;
+  });
+
+  config.async = function(callback, binding) {
+    queue.push([callback, binding]);
+    element.setAttribute('drainQueue', 'drainQueue');
+  };
+} else {
+  config.async = function(callback, binding) {
+    setTimeout(function() {
+      callback.call(binding);
+    }, 1);
+  };
+}
+
+function configure(name, value) {
+  config[name] = value;
+}
+
+export { configure, async };

lib/events.js

+var Event = function(type, options) {
+  this.type = type;
+
+  for (var option in options) {
+    if (!options.hasOwnProperty(option)) { continue; }
+
+    this[option] = options[option];
+  }
+};
+
+var indexOf = function(callbacks, callback) {
+  for (var i=0, l=callbacks.length; i<l; i++) {
+    if (callbacks[i][0] === callback) { return i; }
+  }
+
+  return -1;
+};
+
+var callbacksFor = function(object) {
+  var callbacks = object._promiseCallbacks;
+
+  if (!callbacks) {
+    callbacks = object._promiseCallbacks = {};
+  }
+
+  return callbacks;
+};
+
+var EventTarget = {
+  mixin: function(object) {
+    object.on = this.on;
+    object.off = this.off;
+    object.trigger = this.trigger;
+    return object;
+  },
+
+  on: function(eventNames, callback, binding) {
+    var allCallbacks = callbacksFor(this), callbacks, eventName;
+    eventNames = eventNames.split(/\s+/);
+    binding = binding || this;
+
+    while (eventName = eventNames.shift()) {
+      callbacks = allCallbacks[eventName];
+
+      if (!callbacks) {
+        callbacks = allCallbacks[eventName] = [];
+      }
+
+      if (indexOf(callbacks, callback) === -1) {
+        callbacks.push([callback, binding]);
+      }
+    }
+  },
+
+  off: function(eventNames, callback) {
+    var allCallbacks = callbacksFor(this), callbacks, eventName, index;
+    eventNames = eventNames.split(/\s+/);
+
+    while (eventName = eventNames.shift()) {
+      if (!callback) {
+        allCallbacks[eventName] = [];
+        continue;
+      }
+
+      callbacks = allCallbacks[eventName];
+
+      index = indexOf(callbacks, callback);
+
+      if (index !== -1) { callbacks.splice(index, 1); }
+    }
+  },
+
+  trigger: function(eventName, options) {
+    var allCallbacks = callbacksFor(this),
+        callbacks, callbackTuple, callback, binding, event;
+
+    if (callbacks = allCallbacks[eventName]) {
+      // Don't cache the callbacks.length since it may grow
+      for (var i=0; i<callbacks.length; i++) {
+        callbackTuple = callbacks[i];
+        callback = callbackTuple[0];
+        binding = callbackTuple[1];
+
+        if (typeof options !== 'object') {
+          options = { detail: options };
+        }
+
+        event = new Event(eventName, options);
+        callback.call(binding, event);
+      }
+    }
+  }
+};
+
+export { EventTarget };

lib/loader.js

+var define, requireModule;
+
+(function() {
+  var registry = {}, seen = {};
+
+  define = function(name, deps, callback) {
+    registry[name] = { deps: deps, callback: callback };
+  };
+
+  requireModule = function(name) {
+    if (seen[name]) { return seen[name]; }
+    seen[name] = {};
+
+    var mod = registry[name],
+        deps = mod.deps,
+        callback = mod.callback,
+        reified = [],
+        exports;
+
+    for (var i=0, l=deps.length; i<l; i++) {
+      if (deps[i] === 'exports') {
+        reified.push(exports = {});
+      } else {
+        reified.push(requireModule(deps[i]));
+      }
+    }
+
+    var value = callback.apply(this, reified);
+    return seen[name] = exports || value;
+  };
+})();

lib/rsvp.js

-var config = {};
-
-var browserGlobal = (typeof window !== 'undefined') ? window : {};
-
-var MutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-var RSVP;
-
-if (typeof process !== 'undefined' &&
-  {}.toString.call(process) === '[object process]') {
-  config.async = function(callback, binding) {
-    process.nextTick(function() {
-      callback.call(binding);
-    });
-  };
-} else if (MutationObserver) {
-  var queue = [];
-
-  var observer = new MutationObserver(function() {
-    var toProcess = queue.slice();
-    queue = [];
-
-    toProcess.forEach(function(tuple) {
-      var callback = tuple[0], binding = tuple[1];
-      callback.call(binding);
-    });
-  });
-
-  var element = document.createElement('div');
-  observer.observe(element, { attributes: true });
-
-  // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
-  window.addEventListener('unload', function(){
-    observer.disconnect();
-    observer = null;
-  });
-
-  config.async = function(callback, binding) {
-    queue.push([callback, binding]);
-    element.setAttribute('drainQueue', 'drainQueue');
-  };
-} else {
-  config.async = function(callback, binding) {
-    setTimeout(function() {
-      callback.call(binding);
-    }, 1);
-  };
-}
-
-var Event = function(type, options) {
-  this.type = type;
-
-  for (var option in options) {
-    if (!options.hasOwnProperty(option)) { continue; }
-
-    this[option] = options[option];
-  }
-};
-
-var indexOf = function(callbacks, callback) {
-  for (var i=0, l=callbacks.length; i<l; i++) {
-    if (callbacks[i][0] === callback) { return i; }
-  }
-
-  return -1;
-};
-
-var callbacksFor = function(object) {
-  var callbacks = object._promiseCallbacks;
-
-  if (!callbacks) {
-    callbacks = object._promiseCallbacks = {};
-  }
-
-  return callbacks;
-};
-
-var EventTarget = {
-  mixin: function(object) {
-    object.on = this.on;
-    object.off = this.off;
-    object.trigger = this.trigger;
-    return object;
-  },
-
-  on: function(eventNames, callback, binding) {
-    var allCallbacks = callbacksFor(this), callbacks, eventName;
-    eventNames = eventNames.split(/\s+/);
-    binding = binding || this;
-
-    while (eventName = eventNames.shift()) {
-      callbacks = allCallbacks[eventName];
-
-      if (!callbacks) {
-        callbacks = allCallbacks[eventName] = [];
-      }
-
-      if (indexOf(callbacks, callback) === -1) {
-        callbacks.push([callback, binding]);
-      }
-    }
-  },
-
-  off: function(eventNames, callback) {
-    var allCallbacks = callbacksFor(this), callbacks, eventName, index;
-    eventNames = eventNames.split(/\s+/);
+import { async } from "rsvp/async";
+import { EventTarget } from "rsvp/events";
 
-    while (eventName = eventNames.shift()) {
-      if (!callback) {
-        allCallbacks[eventName] = [];
-        continue;
-      }
-
-      callbacks = allCallbacks[eventName];
-
-      index = indexOf(callbacks, callback);
-
-      if (index !== -1) { callbacks.splice(index, 1); }
-    }
-  },
-
-  trigger: function(eventName, options) {
-    var allCallbacks = callbacksFor(this),
-        callbacks, callbackTuple, callback, binding, event;
-
-    if (callbacks = allCallbacks[eventName]) {
-      // Don't cache the callbacks.length since it may grow
-      for (var i=0; i<callbacks.length; i++) {
-        callbackTuple = callbacks[i];
-        callback = callbackTuple[0];
-        binding = callbackTuple[1];
-
-        if (typeof options !== 'object') {
-          options = { detail: options };
-        }
-
-        event = new Event(eventName, options);
-        callback.call(binding, event);
-      }
-    }
-  }
-};
+var config = {};
+config.async = async;
 
 var noop = function() {};
 
@@ -208,15 +72,15 @@ Promise.prototype = {
   then: function(done, fail) {
     var thenPromise = new Promise();
 
-    if (this.isResolved) {
+    if (this.isFulfilled) {
       config.async(function() {
-        invokeCallback('resolve', thenPromise, done, { detail: this.resolvedValue });
+        invokeCallback('resolve', thenPromise, done, { detail: this.fulfillmentValue });
       }, this);
     }
 
     if (this.isRejected) {
       config.async(function() {
-        invokeCallback('reject', thenPromise, fail, { detail: this.rejectedValue });
+        invokeCallback('reject', thenPromise, fail, { detail: this.rejectedReason });
       }, this);
     }
 
@@ -235,8 +99,8 @@ Promise.prototype = {
 function resolve(promise, value) {
   config.async(function() {
     promise.trigger('promise:resolved', { detail: value });
-    promise.isResolved = true;
-    promise.resolvedValue = value;
+    promise.isFulfilled = true;
+    promise.fulfillmentValue = value;
   });
 }
 
@@ -244,7 +108,7 @@ function reject(promise, value) {
   config.async(function() {
     promise.trigger('promise:failed', { detail: value });
     promise.isRejected = true;
-    promise.rejectedValue = value;
+    promise.rejectedReason = value;
   });
 }