Talents should be applicable to Class as static methods. Closes #19.

Author: elmasse

lib/cocktail.js

@@ -29,7 +29,7 @@ cocktail = {
     _processors: {},
 
     /**
-     * @protected   
+     * @protected
      * Returns the processor list map
      */
     getProcessors : function(){
@@ -63,7 +63,7 @@ cocktail = {
         for(key in processorsConfig){
             if(processorsConfig.hasOwnProperty(key)){
                 processors[key] =  processorsConfig[key];
-            }        
+            }
         }
     },
 
@@ -108,7 +108,7 @@ cocktail = {
      */
     _configureProcessorsWith: function(options){
         var key, value, processor;
-        
+
         this._cleanQueue();
 
         if(options){
@@ -219,7 +219,7 @@ cocktail = {
             }
         }
 
-        return isClassDef; 
+        return isClassDef;
     },
 
     /**
@@ -233,7 +233,7 @@ cocktail = {
     /**
      * @private
      * If the subject has a property construtor returns it,
-     * if no constructor on subject but it extends then return a function() calling super constructor, 
+     * if no constructor on subject but it extends then return a function() calling super constructor,
      * or a function definition otherwise.
      */
     _getDefaultClassConstructor: function (subject) {
@@ -278,8 +278,8 @@ cocktail = {
 
         defaultConstructor = this._getDefaultClassConstructor(subject);
         if(this._isPropertyDefinedIn('constructor', subject)) {
-            delete subject.constructor;  
-        } 
+            delete subject.constructor;
+        }
         options = subject;
         return this.mix(defaultConstructor, options);
     },
@@ -305,10 +305,10 @@ cocktail = {
             if (this._isModuleDefinition(subject)) {
                 return this._processModuleDefinition(subject);
             }
-        } 
+        }
 
         if(subject){
-            this._pushQueue();            
+            this._pushQueue();
             this._applyDefaultsOptions(options);
             this._configureProcessorsWith(options);
             this._executeProcessorsOn(subject, options);
@@ -335,7 +335,7 @@ cocktail._DEFAULT_PROCESSORS = {
     '@properties' : require('./processor/annotation/Properties'),
     '@traits'     : require('./processor/annotation/Traits'),
     '@requires'   : require('./processor/annotation/Requires'),
-    '@talents'    : require('./processor/annotation/Traits'),
+    '@talents'    : require('./processor/annotation/Talents'),
     '@annotation' : require('./processor/annotation/Annotation'),
     '@exports'    : require('./processor/annotation/Exports'),
     '@static'     : require('./processor/annotation/Static'),

lib/processor/annotation/Talents.js

@@ -0,0 +1,30 @@
+/*
+*
+* Copyright (c) 2013 - 2014 Maximiliano Fierro
+* Licensed under the MIT license.
+*/
+'use strict';
+
+
+var Traits = require('./Traits'),
+	Talents;
+
+Talents = function(){
+	Traits.call(this);
+};
+
+Talents.prototype = Object.create(Traits.prototype);
+
+Talents.prototype._applyTalentTo = Traits.prototype._applyTraitTo;
+
+Talents.prototype.process = function(subject){
+	var traits = this.getParameter(), // always an []
+		l = traits.length,
+		i;
+
+	for(i = 0; i < l; i++){
+		this._applyTalentTo(subject, traits[i]);
+	}
+};
+
+module.exports = Talents;

test/unit/processor/annotation/Talents.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var chai = require("chai"),
+	expect = chai.expect,
+	cocktail = require('../../../../lib/cocktail'),
+	// Requires = require('../../../../lib/processor/annotation/Requires.js'),
+	Talents = require('../../../../lib/processor/annotation/Talents.js');
+
+describe('Annotation Processor @talents', function(){
+	var sut = new Talents();
+
+	it('has retain set false', function(){
+		expect(sut.retain).to.equal(false);
+	});
+
+	it('has priority set to cocktail.SEQUENCE.TRAITS', function(){
+		expect(sut.priority).to.equal(cocktail.SEQUENCE.TRAITS);
+	});
+
+	describe('Parameter for @talents annotation', function(){
+
+		it('accepts an array of Talents as parameter', function(){
+			var sut = new Talents(),
+				traitDef = {};
+
+			sut.setParameter([traitDef]);
+
+			expect(sut.getParameter()).to.contain(traitDef);
+		});
+	});
+
+	describe('Talents process', function(){
+
+		describe('Passing a Talent reference `@talents:[TalentA]`', function(){
+			var sut = new Talents(),
+				TalentA = function(){},
+				myObj = {},
+				aMethod = function method(){};
+
+			TalentA.prototype.aMethod = aMethod;
+			myObj.foo = 1;
+
+			sut.setParameter([TalentA]);
+
+			sut.process(myObj);
+
+			it('makes the TalentA methods part of the given myObj', function(){
+				expect(myObj).to.respondTo('aMethod');
+				expect(myObj.aMethod).to.be.equal(aMethod);
+			});
+		});
+
+
+		describe('Passing a Talent using options object `@talents: [{talent: TalentA}]`', function(){
+			var sut = new Talents(),
+				TalentA = function(){},
+				myObj = {},
+				aMethod = function method(){};
+
+			TalentA.prototype.aMethod = aMethod;
+			myObj.foo = 1;
+
+			sut.setParameter([{talent: TalentA}]);
+
+			sut.process(myObj);
+
+			it('makes the TalentA methods part of the given myObj', function(){
+				expect(myObj).to.respondTo('aMethod');
+				expect(myObj.aMethod).to.be.equal(aMethod);
+			});
+		});
+
+		describe('Passing a Talent reference `@talents:[TalentA]` to a Class', function(){
+			var sut = new Talents(),
+				TalentA = function(){},
+				MyClass = function(){},
+				aMethod = function method(){};
+
+			TalentA.prototype.aMethod = aMethod;
+			MyClass.prototype.foo = 1;
+
+			sut.setParameter([TalentA]);
+
+			sut.process(MyClass);
+
+			it('makes the TalentA methods part of the given MyClass as static method', function(){
+				expect(MyClass).to.not.respondTo('aMethod');
+				expect(MyClass.aMethod).to.be.equal(aMethod);
+			});
+		});
+
+	});
+});