Code coverage report for src/core/Class.js

Statements: 100% (46 / 46)      Branches: 87.5% (21 / 24)      Functions: 88.89% (8 / 9)      Lines: 100% (45 / 45)     

All files » src/core/ » Class.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105          1   1     67     594 580       594 594         67 67   67 67   67     67 332 332         67 17 17       67 32 32       67 12       67   67   67 67   67   1101   1051 457     1051   1051 455       67         1 16       1 10       1 15   15 301     15 15    
/*
 * L.Class powers the OOP facilities of the library.
 * Thanks to John Resig and Dean Edwards for inspiration!
 */
 
L.Class = function () {};
 
L.Class.extend = function (props) {
 
	// extended class with the new prototype
	var NewClass = function () {
 
		// call the constructor
		if (this.initialize) {
			this.initialize.apply(this, arguments);
		}
 
		// call all constructor hooks
		Eif (this._initHooks) {
			this.callInitHooks();
		}
	};
 
	// instantiate class without calling constructor
	var F = function () {};
	F.prototype = this.prototype;
 
	var proto = new F();
	proto.constructor = NewClass;
 
	NewClass.prototype = proto;
 
	//inherit parent's statics
	for (var i in this) {
		Eif (this.hasOwnProperty(i) && i !== 'prototype') {
			NewClass[i] = this[i];
		}
	}
 
	// mix static properties into the class
	if (props.statics) {
		L.extend(NewClass, props.statics);
		delete props.statics;
	}
 
	// mix includes into the prototype
	if (props.includes) {
		L.Util.extend.apply(null, [proto].concat(props.includes));
		delete props.includes;
	}
 
	// merge options
	if (props.options && proto.options) {
		props.options = L.extend({}, proto.options, props.options);
	}
 
	// mix given properties into the prototype
	L.extend(proto, props);
 
	proto._initHooks = [];
 
	var parent = this;
	NewClass.__super__ = parent.prototype;
	// add method for calling all hooks
	proto.callInitHooks = function () {
 
		if (this._initHooksCalled) { return; }
 
		if (parent.prototype.callInitHooks) {
			parent.prototype.callInitHooks.call(this);
		}
 
		this._initHooksCalled = true;
 
		for (var i = 0, len = proto._initHooks.length; i < len; i++) {
			proto._initHooks[i].call(this);
		}
	};
 
	return NewClass;
};
 
 
// method for adding properties to prototype
L.Class.include = function (props) {
	L.extend(this.prototype, props);
};
 
// merge new default options to the Class
L.Class.mergeOptions = function (options) {
	L.extend(this.prototype.options, options);
};
 
// add a constructor hook
L.Class.addInitHook = function (fn) { // (Function) || (String, args...)
	var args = Array.prototype.slice.call(arguments, 1);
 
	var init = typeof fn === 'function' ? fn : function () {
		this[fn].apply(this, args);
	};
 
	this.prototype._initHooks = this.prototype._initHooks || [];
	this.prototype._initHooks.push(init);
};