Scandio.util = {};
Register util namespace on scandiojs object
Scandio.util = {};
Nothing too fancy: shorthand to hasOwnProperty
Scandio.util.has = function(obj, key) {
return hasOwnProperty.call(obj, key);
};
Iterates over an object
with an iterator
in an optional context
Falls back to nativeForEach if supported by browser (on prototpye)
Scandio.util.each = Scandio.forEach = function(obj, iterator, context) {
var
key = null,
i = null,
l = null;
Nothing to iterate, somewhat funny eh?
if (obj === null || obj === undefined) { return; }
Fall back to native foreach which is faster in newer browsers
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context);
}
Passed obj
has a length property, meaning its an array
and an optimized for-loop can be used.
else if (obj.length === +obj.length) {
Iterate over length of obj
for (i = 0, l = obj.length; i < l; i++) {
…call the iterator
-function and return if its the breaker (done)
if (iterator.call(context, obj[i], i, obj) === breaker) { return; }
}
}
Iterate over object
else {
For each key in obj
for (key in obj) {
Only if it hasOwnProperty
if (Scandio.util.has(obj, key)) {
…call the iterator
-function and return if its the breaker (done)
if (iterator.call(context, obj[key], key, obj) === breaker) { return; }
}
}
}
};
Extends an object with all the arguments passed in other objects
Scandio.util.extend = function(obj) {
obj
is destination arguments
-2nd parater is source
Scandio.util.each(slice.call(arguments, 1), function(source) {
Source is set
if (source) {
For every property in source
for (var prop in source) {
Set it on the object without checking prior existence
obj[prop] = source[prop];
}
}
});
return obj;
};
Iterates over an object
with an iterator
in an optional context
while results will only contain values if they pass the iterator
-test
Scandio.util.filter = function(obj, iterator, context) {
What will be returned
var results = [];
Nothing to iterate
if (obj === null || obj === undefined) { return results; }
Fallback to native filter for performance reasons
if (nativeFilter && obj.filter === nativeFilter)
{ return obj.filter(iterator, context); }
Foreach value
with index
and the context
being list
Scandio.util.each(obj, function(value, index, list) {
Push the value to results
if test passes as specified in iterator
if(iterator.call(context, value, index, list)) {
results.push(value);
}
});
return results;
};
Accesses an obj by dot-notation allowing a default/notFound value E.g.: Scandio.util.getByDots(“name.fullname”, {name: {fullname: ‘me’}}) returns me
Scandio.util.getByDots = function(dots, obj, notFound) {
Setup path and destination variables
var
dest = obj,
path = dots.split('.'),
i = null;
Dig into the path
an question the obj
for(i = 0; i < path.length; i++) {
Found something on the obj
and reset the destination
if ( dest[path[i]] ) { dest = dest[path[i]]; }
Nothing found…
else {
dest = undefined;
break;
}
}
Dest or notFound
return dest || notFound;
};
Sets an obj by dot-notation E.g.: Scandio.util.setByDots(“name.firstname”, “doop”, {name: {fullname: ‘me’}}) returns me
Scandio.util.setByDots = function(dots, value, obj) {
Split string by dots
var
path = dots.split("."),
key = null;
Moves in on the path
while (path.length > 1) {
Gets the latest key
key = path.shift();
Creates empty object if not found
if (!Scandio.isObject(obj)) { obj = {}; }
if (!(key in obj)) { obj[key] = {}; }
Sets the nesting to next deeper key
obj = obj[key];
}
Returns the result of setting the value
return obj[ path[0] ] = value;
};
Collects all function from an object and returns an array containing them
E.g.: calling it with Scandio.util.functions({capitalize: function() {return}, greet: ‘hi’})
would only return an array containing the capitalize
function.
Scandio.util.functions = function(obj) {
Setup local variables
var
functions = {},
key = null;
For each key in object…
for (key in obj) {
…check if it is a function and push it to result
if (Scandio.isFunction(obj[key])) { functions[key] = obj[key]; }
}
return functions;
};
Allows for extending Scandio. functionality by handing in an namespace
and a object-literal
containing the functions.
E.g.: calling Scandio.util.mixin('string', {capitalize: fn(string)})
makes the capitalize function
available as in Scandio.string.capitalize(‘string’).
Scandio.util.mixin = function(namespace, obj) {
var
destination = Scandio,
path = namespace !== null ? namespace.split(".") : [],
atModule = null,
i = null;
Register the namespace if its not existent
for (i = 0; i < path.length; i++) {
The current sub/module
atModule = path[i];
Namespace not registered yet
if (!destination[ atModule ]) {
destination[ atModule ] = {};
}
Sets the current pointer to module
destination = destination[ atModule ];
}
For each function on the passed in obj
by name
Scandio.util.each(Scandio.util.functions(obj), function(func, name) {
Defines the function on the destination module
destination[name] = function() {
Merge args with wrapped object (constructor new Scandio.(obj))
var args = this._wrapped ? [this._wrapped] : [];
push.apply(args, arguments);
The result of applying the function with Scandio. and its args
return func.apply(Scandio, args);
};
});
};