1 files changed, 183 insertions, 0 deletions
diff --git a/tools/addon-sdk-1.5/packages/api-utils/lib/traits.js b/tools/addon-sdk-1.5/packages/api-utils/lib/traits.js
new file mode 100644
index 0000000..7c1c4ec
--- /dev/null
+++ b/tools/addon-sdk-1.5/packages/api-utils/lib/traits.js
@@ -0,0 +1,183 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const {
+  compose: _compose,
+  override: _override,
+  resolve: _resolve,
+  trait: _trait,
+  //create: _create,
+  required,
+} = require('./traits/core');
+
+const defineProperties = Object.defineProperties,
+      freeze = Object.freeze,
+      create = Object.create;
+
+/**
+ * Work around bug 608959 by defining the _create function here instead of
+ * importing it from traits/core.  For docs on this function, see the create
+ * function in that module.
+ *
+ * FIXME: remove this workaround in favor of importing the function once that
+ * bug has been fixed.
+ */
+function _create(proto, trait) {
+  let properties = {},
+      keys = Object.getOwnPropertyNames(trait);
+  for each(let key in keys) {
+    let descriptor = trait[key];
+    if (descriptor.required &&
+        !Object.prototype.hasOwnProperty.call(proto, key))
+      throw new Error('Missing required property: ' + key);
+    else if (descriptor.conflict)
+      throw new Error('Remaining conflicting property: ' + key);
+    else
+      properties[key] = descriptor;
+  }
+  return Object.create(proto, properties);
+}
+
+/**
+ * Placeholder for `Trait.prototype`
+ */
+let TraitProto = Object.prototype;
+
+function Get(key) this[key]
+function Set(key, value) this[key] = value
+
+/**
+ * Creates anonymous trait descriptor from the passed argument, unless argument
+ * is a trait constructor. In later case trait's already existing properties
+ * descriptor is returned.
+ * This is module's internal function and is used as a gateway to a trait's
+ * internal properties descriptor.
+ * @param {Function} $
+ *    Composed trait's constructor.
+ * @returns {Object}
+ *    Private trait property of the composition.
+ */
+function TraitDescriptor(object)
+  (
+    'function' == typeof object &&
+    (object.prototype == TraitProto || object.prototype instanceof Trait)
+  ) ? object._trait(TraitDescriptor) : _trait(object)
+
+function Public(instance, trait) {
+  let result = {},
+      keys = Object.getOwnPropertyNames(trait);
+  for each (let key in keys) {
+    if ('_' === key.charAt(0) && '__iterator__' !== key )
+      continue;
+    let property = trait[key],
+        descriptor = {
+          configurable: property.configurable,
+          enumerable: property.enumerable
+        };
+    if (property.get)
+      descriptor.get = property.get.bind(instance);
+    if (property.set)
+      descriptor.set = property.set.bind(instance);
+    if ('value' in property) {
+      let value = property.value;
+      if ('function' === typeof value) {
+        descriptor.value = property.value.bind(instance);
+        descriptor.writable = property.writable;
+      } else {
+        descriptor.get = Get.bind(instance, key);
+        descriptor.set = Set.bind(instance, key);
+      }
+    }
+    result[key] = descriptor;
+  }
+  return result;
+}
+
+/**
+ * This is private function that composes new trait with privates.
+ */
+function Composition(trait) {
+  function Trait() {
+    let self = _create({}, trait);
+    self._public = create(Trait.prototype, Public(self, trait));
+    delete self._public.constructor;
+    if (Object === self.constructor)
+      self.constructor = Trait;
+    else
+      return self.constructor.apply(self, arguments) || self._public;
+    return self._public;
+  }
+  defineProperties(Trait, {
+    prototype: { value: freeze(create(TraitProto, {
+      constructor: { value: constructor, writable: true }
+    }))}, // writable is `true` to avoid getters in custom ES5
+    displayName: { value: (trait.constructor || constructor).name },
+    compose: { value: compose, enumerable: true },
+    override: { value: override, enumerable: true },
+    resolve: { value: resolve, enumerable: true },
+    required: { value: required, enumerable: true },
+    _trait: { value: function _trait(caller)
+        caller ===  TraitDescriptor ? trait : undefined
+    }
+  });
+  return freeze(Trait);
+}
+
+/**
+ * Composes new trait out of itself and traits / property maps passed as an
+ * arguments. If two or more traits / property maps have properties with the
+ * same name, the new trait will contain a "conflict" property for that name.
+ * This is a commutative and associative operation, and the order of its
+ * arguments is not significant.
+ * @params {Object|Function}
+ *    List of Traits or property maps to create traits from.
+ * @returns {Function}
+ *    New trait containing the combined properties of all the traits.
+ */
+function compose() {
+  let traits = Array.slice(arguments, 0);
+  traits.push(this);
+  return Composition(_compose.apply(null, traits.map(TraitDescriptor)));
+}
+
+/**
+ * Composes a new trait with all of the combined properties of `this` and the
+ * argument traits. In contrast to `compose`, `override` immediately resolves
+ * all conflicts resulting from this composition by overriding the properties of
+ * later traits. Trait priority is from left to right. I.e. the properties of
+ * the leftmost trait are never overridden.
+ * @params {Object} trait
+ * @returns {Object}
+ */
+function override() {
+  let traits = Array.slice(arguments, 0);
+  traits.push(this);
+  return Composition(_override.apply(null, traits.map(TraitDescriptor)));
+}
+
+/**
+ * Composes new resolved trait, with all the same properties as this
+ * trait, except that all properties whose name is an own property of
+ * `resolutions` will be renamed to `resolutions[name]`. If it is
+ * `resolutions[name]` is `null` value is changed into a required property
+ * descriptor.
+ */
+function resolve(resolutions)
+  Composition(_resolve(resolutions, TraitDescriptor(this)))
+
+/**
+ * Base Trait, that all the traits are composed of.
+ */
+const Trait = Composition({
+  /**
+   * Internal property holding public API of this instance.
+   */
+  _public: { value: null, configurable: true, writable: true },
+  toString: { value: function() '[object ' + this.constructor.name + ']' }
+});
+TraitProto = Trait.prototype;
+exports.Trait = Trait;
+