reimporting, phase 2

[mootools.git] / Moo.js

/*
Script: Moo.js
        My Object Oriented javascript.
        
Dependancies:
         Has no dependancies.
        
Author:
        Valerio Proietti, <http://mad4milk.net>

License:
        MIT-style license.

Credits:
        - Class is slightly based on Base.js  <http://dean.edwards.name/weblog/2006/03/base/> (c) 2006 Dean Edwards, License <http://creativecommons.org/licenses/LGPL/2.1/>
        - Some functions are based on those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
        - Documentation by Aaron Newton (aaron.newton [at] cnet [dot] com) and Valerio Proietti.
*/

/*
Class: Class
        The base class object of the <http://mootools.net> framework.
        
Arguments:
        properties - the collection of properties that apply to the class. Creates a new class, its initialize method will fire upon class instantiation.
        
Example:
        >var Cat = new Class({
        >       initialize: function(name){
        >               this.name = name;
        >       }
        >});
        >var myCat = new Cat('Micia');
        >alert myCat.name; //alerts 'Micia'
*/

var Class = function(properties){
        var klass = function(){
                for (var p in this){
                        if (this[p]) this[p]._proto_ = this;
                }
                if (arguments[0] != 'noinit' && this.initialize) return this.initialize.apply(this, arguments);
        };
        klass.extend = this.extend;
        klass.implement = this.implement;
        klass.prototype = properties;
        return klass;
};

/*
Property: empty
        Returns an empty function
*/

Class.empty = function(){};

/*
Property: create
        same as new Class. see <Class>
*/

Class.create = function(properties){
        return new Class(properties);
};

Class.prototype = {

        /*
        Property: extend
                Returns the copy of the Class extended with the passed in properties.
                
        Arguments:
                properties - the properties to add to the base class in this new Class.
                
        Example:
                >var Animal = new Class({
                >       initialize: function(age){
                >               this.age = age;
                >       }
                >});
                >var Cat = Animal.extend({
                >       initialize: function(name, age){
                >               this.parent(age); //will call the previous initialize;
                >               this.name = name;
                >       }
                >});
                >var myCat = new Cat('Micia', 20);
                >alert myCat.name; //alerts 'Micia'
                >alert myCat.age; //alerts 20
        */

        extend: function(properties){
                var pr0t0typ3 = new this('noinit');
                for (var property in properties){
                        var previous = pr0t0typ3[property];
                        var current = properties[property];
                        if (previous && previous != current) current = previous.parentize(current) || current;
                        pr0t0typ3[property] = current;
                }
                return new Class(pr0t0typ3);
        },
        
        /*      
        Property: implement
                Implements the passed in properties to the base Class prototypes, altering the base class, unlike <Class.extend>.

        Arguments:
                properties - the properties to add to the base class.
                
        Example:
                >var Animal = new Class({
                >       initialize: function(age){
                >               this.age = age;
                >       }
                >});
                >Animal.implement({
                >       setName: function(name){
                >               this.name = name
                >       }
                >});
                >var myAnimal = new Animal(20);
                >myAnimal.setName('Micia');
                >alert(myAnimal.name); //alerts 'Micia'
        */
        
        implement: function(properties){
                for (var property in properties) this.prototype[property] = properties[property];
        }

};

/* Section: Object related Functions  */

/*
Function: Object.extend
        Copies all the properties from the second passed object to the first passed Object.
        If you do myWhatever.extend = Object.extend the first parameter will become myWhatever, and your extend function will only need one parameter.
                
Example:
        >var firstOb = {
        >       'name': 'John',
        >       'lastName': 'Doe'
        >};
        >var secondOb = {
        >       'age': '20',
        >       'sex': 'male',
        >       'lastName': 'Dorian'
        >};
        >Object.extend(firstOb, secondOb);
        >//firstOb will become: 
        >{
        >       'name': 'John',
        >       'lastName': 'Dorian',
        >       'age': '20',
        >       'sex': 'male'
        >};
        
Returns:
        The first object, extended.
*/

Object.extend = function(){
        var args = arguments;
        if (args[1]) args = [args[0], args[1]];
        else args = [this, args[0]];
        for (var property in args[1]) args[0][property] = args[1][property];
        return args[0];
};

/*
Function: Object.Native
        Will add a .extend method to the objects passed as a parameter, equivalent to <Class.implement>

Arguments:
        a number of classes/native javascript objects

*/

Object.Native = function(){
        for (var i = 0; i < arguments.length; i++) arguments[i].extend = Class.prototype.implement;
};

new Object.Native(Function, Array, String, Number);

Function.extend({

        parentize: function(current){
                var previous = this;
                return function(){
                        this.parent = previous;
                        return current.apply(this, arguments);
                };
        }

});