The Tor Browser: addon-sdk/source/lib/sdk/deprecated/traits.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/deprecated/traits.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/deprecated/traits.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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;