1 files changed, 0 insertions, 187 deletions
diff --git a/tools/addon-sdk-1.12/lib/sdk/deprecated/traits.js b/tools/addon-sdk-1.12/lib/sdk/deprecated/traits.js
deleted file mode 100644
index 30ae342..0000000
--- a/tools/addon-sdk-1.12/lib/sdk/deprecated/traits.js
+++ /dev/null
@@ -1,187 +0,0 @@
-/* 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";
-
-module.metadata = {
-  "stability": "deprecated"
-};
-
-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;
-