extendable.js v0.0.1

#Extendable.js

A Node.js, AMD module, or global module which assists in extending objects and overriding object methods using prototypal inheritance.

#Usage

##Node.js

    var Extendable = require('extendable.js');

##AMD require

require(['extendable.js'], function(Extendable) {
    //
});

or you can use it as a global variable window.Extendable in your browser.

#Examples

##Extension of object literals

###extend()

extend(props) creates a new object, set the current object (this) as the object's prototype and copies the first-level properties of props to the new object.

var props = {
    a: 1,
    b: {
      c: 3
    }
};
var extended = Extendable.extend(props);

Object extended has properties a and b copied from props and it's prototype is Extendable:

extended.a === props.a;             // returns true
extended.b === props.b;             // returns true
Extendable.isPrototypeOf(extended); // returns true

###create()

Acts the same as if the extend() was called without any arguments, returns the same as calling Object.create(this).

###override()

override(methodName, newMethod) overrides an existing method methodName in the object and adds the ability to call the overridden method from the new method:

var obj1 = Extendable.extend({
    value: 5,
    calculate: function(a) {
        return this.value + a;
    }
});

var obj2 = obj1.extend().override('calculate', function(p_super, a, b) {
    return p_super(a) + b;
});

obj1.calculate(3);     // returns 8
obj2.calculate(3, 10); // returns 18

Additional combinations are possible:

var original = {
    a: 1,
    b: 2,
    sum: function(c, d) {
        return this.a + this.b + c + d;
    }
};

var extended = Extendable.extend(original)
    // override the sum method
    .override('sum', function(p_super, c, d) {
        var value = p_super(c, d);
        return value * 2;
    })
    // extend the object with the overridden method and modify the
    // variable which is used in the overridden method.
    .extend({
        b: 5
    });

original.sum(3, 4); // 1 + 2 + 3 + 4 = 10
extended.sum(3, 4); // (1 + 5 + 3 + 4) * 2 = 26

##Constructor extension

// Person.js AMD module
define(['Extendable'], function(Extendable) {
    
    function Person(name) {
        this.name = name;
    }
    
    var PersonPrototype = {
        setJob: function(job) {
            this.job = job;
        },
        setAge: function(age) {
            this.age = age;
        }
    };
    
    return Extendable.extend(Person, PersonPrototype);
    
});

// Plumber.js AMD module
define(['Person'], function(Person) {
    
    function Plumber(name, tools) {
        this.superclass.call(this, name);
        
        this.setJob('plumber');
        this.setAge(25);
        this.setTools(tools);
    }
    
    var PlumberPrototype = {
        setTools: function(tools) {
            this.tools = tools;
        }
    };
    
    return Person.extend(Plumber, PlumberPrototype);
});

// index.js
require(['Plumber', 'Person'], function(Plumber, Person) {

    var joe = new Plumber('joe johnson', 'wrench');
    
    // joe instanceof Plumber returns true
    // joe instanceof Person returns true
    // Person.prototype.isPrototypeOf(joe) returns true
    // Plumber.prototype.isPrototypeOf(joe) returns true
    
    // joe.name is 'joe johnson'
    // joe.age is 25
    // joe.job is 'plumber'
    // joe.tools is 'wrench'

});

#License

MIT