Enable ES6 Classes as Traits. Make sure properties descriptors are kept in Host as in Trait.Closes #24.

Author: elmasse

lib/processor/annotation/Traits.js

@@ -44,24 +44,29 @@ Traits.prototype = {
     },
 
     _applyTo: function (subject, options) {
-        var type = this._configName,
+        var me = this,
+            type = me._configName,
             o = {},
-            key, tp, excluded, aliases, t;
+            tp, excluded, aliases, t;
 
-        if (this._isApplicable(options)) {
+        if (me._isApplicable(options)) {
             o[type] = options;
-           return this._applyTo(subject, o);
+           return me._applyTo(subject, o);
         }
 
         excluded = [].concat(options.excludes);
         aliases = options.alias || {};
         t = options[type];
         tp = t.prototype || t;
 
-        for (key in tp) {
-            this._raiseErrorIfItIsState(key, tp);
-            this._applyIfNotExcluded(key, excluded, aliases, subject, tp);
-        }
+        Object.getOwnPropertyNames(tp)
+            .filter(function(key){
+                return !key.match(/^(?:constructor|prototype|arguments|caller|name|bind|call|apply|toString|length)$/);
+            })
+            .forEach(function(key){
+                me._raiseErrorIfItIsState(key, tp);
+                me._applyIfNotExcluded(key, excluded, aliases, subject, tp);
+            });
     },
 
     _applyIfNotExcluded: function (key, excluded, aliases, subject, tp) {
@@ -72,7 +77,7 @@ Traits.prototype = {
             this._raiseErrorIfConflict(alias, subject, tp);
 
             if (!subject[alias] || subject[alias] === Requires.requiredMethod) {
-                subject[alias] = tp[key];
+               Object.defineProperty(subject, alias, Object.getOwnPropertyDescriptor(tp, key));
             }
         }
     },

test/unit/processor/annotation/Traits.js

@@ -70,6 +70,35 @@ describe('Annotation Processor @traits', function(){
             });
         });
 
+        describe('Passing a ES6-type class as Trait reference `@traits:[TraitA]`', function(){
+            var sut = new Traits(),
+                TraitA = function(){},
+                MyClass = function(){},
+                aMethod = function method(){},
+                propDesc = {
+                    enumerable: false,
+                    value: aMethod
+                };
+
+            Object.defineProperty(
+                TraitA.prototype,
+                'aMethod',
+                propDesc
+            );
+            sut.setParameter([TraitA]);
+
+            sut.process(MyClass);
+
+            it('makes the TraitA methods part of the given MyClass', function(){
+                expect(MyClass).to.respondTo('aMethod');
+                expect(MyClass.prototype.aMethod).to.be.equal(aMethod);
+            });
+
+            it('makes MyClass method to keep same property descriptor', function(){
+                expect(Object.getOwnPropertyDescriptor(MyClass.prototype, 'aMethod') === propDesc);
+            });
+        });
+
         describe('Passing a Trait class using options object `@traits: [{trait: TraitA}]`', function(){
             var sut = new Traits(),
                 TraitA = function(){},