cocktail

CocktailJS is a small library to explore traits, talents, inheritance and annotations concepts in nodejs - Shake your objects and classes with Cocktail!

Cocktail JS

Cocktail is a small but yet powerful library with very simple principles:

  • Reuse code
  • Keep it simple

Cocktail explores three mechanisms to share/reuse/mix code:

  • Extends: OOP inheritance implemented in Javascript.
  • Traits: Traits are composable behavior units that can be added to a Class.
  • Talents: Same idea as Traits but applied to instances of a Class.

Cocktail has only one public method cocktail.mix() but it relies on annotations to tag some meta-data that describe the mix.

Annotations are simple meta-data Cocktail uses to perform some tasks over the given mix. They become part of the process but usually they are not kept in the result of a mix.

    var cocktail = require('cocktail'),
        MyClass  = function(){};
 
    cocktail.mix(MyClass, {
        '@properties': {
            name: 'default name'
        }
    });

In the example above we created a "Class" named MyClass, and we use the @properties annotation to create the property name and the corresponding setName and getName methods.

As it was mentioned before, annotations are meta-data, which means that they are not part of MyClass or its prototype.

Using cocktail to define a class is easy and elegant.

var cocktail = require('cocktail');
 
cocktail.mix({
    '@exports': module,
    '@as': 'class',
 
    '@properties': {
        name: 'default name'
    },
 
    constructorfunction(name){
        this.setName(name);
    },
 
    sayHellofunction() {
        return 'Hello, my name is ' + this.getName();
    }
});
 

In this example our class definition uses @exports to tell the mix we want to export the result in the module.exports and @as tells it is a class.

Traits are Composable Units of Behaviour (You can read more from this paper). Basically, a Trait is a Class, but a special type of Class that has only behaviour (methods) and no state. Traits are an alternative to reuse behaviour in a more predictable manner. They are more robust than Mixins, or Multiple Inheritance since name collisions must be solved by the developer beforehand. If you compose your class with one or more Traits and you have a method defined in more than one place, your program will fail giving no magic rule or any kind of precedence definition.

Enumerable.js

var cocktail = require('cocktail');
 
cocktail.mix({
    '@exports': module,
    '@as': 'class',
 
    '@requires': ['getItems'],
 
    firstfunction() {
        var items = this.getItems();
        return items[0] || null;
    },
 
    lastfunction() {
        var items = this.getItems(),
            l = items.length;
        return items[l-1];
    }
 
});
 
 

The class above is a Trait declaration for an Enumerable functionality. In this case we only defined first and last methods to retrieve the corresponding elements from an array retrieved by getItems methods.

List.js

var cocktail = require('cocktail'),
    Enumerable = require('./Enumerable');
 
cocktail.mix({
    '@exports': module,
    '@as': 'class',
    '@traits': [Enumerable],
 
    '@properties': {
        items: undefined
    },
 
    '@static': {
        /* factory method*/
        createfunction(options) {
            var List = this;
            return new List(options);
        }
    },
 
    constructorfunction (options) {
        this.items = options.items || [];
    }
});
 
 

The List class uses the Enumerable Trait, the getItems is defined by the @properties annotation.

index.js

var List = require('./List'),
    myArr = ['one', 'two', 'three'],
    myList;
 
myList = List.create({items: myArr});
 
console.log(myList.first()); // 'one' 
console.log(myList.last());  // 'three' 
 
 

Talents are very similar to Traits, in fact a Trait can be applied as a Talent in CocktailJS. The main difference is that a Talent can be applied to an object or module. So we can define a Talent as a Dynamically Composable Unit of Reuse (you can read more from this paper).

Using the Enumerable example, we can use a Trait as a Talent.

index.js

var cocktail = require('cocktail'),
    enumerable = require('./Enumerable'),
    myArr;
 
myArr = ['one', 'two', 'three'];
 
cocktail.mix(myArr, {
    '@talents': [enumerable],
 
    /* glue code for enumerable talent*/
    getItemsfunction () {
        return this;
    }
});
 
console.log(myArr.first());  // 'one' 
console.log(myArr.last());   // 'three' 
 
 

We can also create a new Talent to define the getItems method for an Array to retrive the current instance.

ArrayAsItems.js

var cocktail = require('cocktail');
 
cocktail.mix({
    '@exports': module,
    '@as': 'class',
 
    getItemsfunction () {
        return this;
    }
});
 

And then use it with Enumerable:

var cocktail     = require('cocktail'),
    enumerable   = require('./Enumerable'),
    arrayAsItems = require('./ArrayAsItems');
 
var myArr = ['one', 'two', 'three'];
 
cocktail.mix(myArr, { '@talents': [enumerable, arrayAsItems] });
 
console.log(myArr.first());  // 'one' 
console.log(myArr.last());   // 'three' 
 
  • Install the module with: npm install cocktail or add cocktail to your package.json and then npm install
  • Start playing by just adding a var cocktail = require('cocktail') in your file.

Guides can be found at CocktailJS Guides

The latest documentation is published at CocktailJS Documentation

A Cocktail playground can be found in cocktail recipes repo.

In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality.

Add your unit and/or integration tests and execute

$ npm test
$npm run unit
$npm run integration 
$ npm run lint

Run npm test to check lint and execute tests

$ npm test
$ npm run coverage

see CHANGELOG

Copyright (c) 2013 - 2015 Maximiliano Fierro
Licensed under the MIT license.