2011-04-27 19:39:56 +00:00
|
|
|
|
// vim: et:ts=4:sw=4:sts=4:ft=js
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// OxJS (c) 2011 Ox2620, dual-licensed GPL/MIT, see http://oxjs.org for details
|
2011-05-06 17:40:26 +00:00
|
|
|
|
|
|
|
|
|
// todo: check http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/
|
2011-05-05 18:02:56 +00:00
|
|
|
|
// also see https://github.com/tlrobinson/narwhal/blob/master/lib/util.js
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Core -----------------------------------------------------------------------
|
2011-05-05 18:02:56 +00:00
|
|
|
|
|
|
|
|
|
/*@
|
2011-05-06 17:40:26 +00:00
|
|
|
|
Ox <f> The <code>Ox</code> object
|
|
|
|
|
See <code>Ox.wrap</code> for details.
|
2011-05-05 18:02:56 +00:00
|
|
|
|
(value) -> <o> wrapped value
|
2011-05-06 22:47:17 +00:00
|
|
|
|
value <*> Any value
|
2011-05-05 18:02:56 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox = function(val) {
|
|
|
|
|
return Ox.wrap(val);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.load <f> Loads a module
|
|
|
|
|
(module, callback) -> <u> undefined
|
|
|
|
|
(module, options, callback) -> <u> undefined
|
|
|
|
|
module <s> Module name
|
|
|
|
|
options <o> Module options
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
success <b> If true, the module has been loaded successfully
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.load = function(module, options, callback) {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
// fixme: no way to load multiple modules
|
|
|
|
|
// problem: where do multiple options go?
|
|
|
|
|
// [{name: "", options: {}}, {name: "", options: {}}] isn't pretty
|
2011-04-27 19:39:56 +00:00
|
|
|
|
callback = arguments[arguments.length - 1];
|
|
|
|
|
options = arguments.length == 3 ? arguments[1] : {};
|
|
|
|
|
Ox.loadFile(Ox.PATH + 'Ox.' + module + '/Ox.' + module + '.js', function() {
|
|
|
|
|
Ox.load[module](options, callback);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.print <f> Prints its arguments to the console
|
|
|
|
|
(arg, ...) -> <s> String
|
|
|
|
|
The string contains the timestamp, the name of the caller function, and
|
|
|
|
|
any arguments, separated by spaces
|
|
|
|
|
arg <*> any value
|
|
|
|
|
> Ox.print("foo").substr(-3)
|
|
|
|
|
"foo"
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
|
|
|
|
Ox.print = function() {
|
2011-05-06 17:40:26 +00:00
|
|
|
|
var args = Ox.makeArray(arguments),
|
|
|
|
|
date = new Date();
|
|
|
|
|
args.unshift(
|
|
|
|
|
Ox.formatDate(date, '%H:%M:%S.') + (+date).toString().substr(-3),
|
2011-05-06 22:47:17 +00:00
|
|
|
|
(arguments.callee.caller && arguments.callee.caller.name) ||
|
|
|
|
|
'(anonymous)'
|
2011-05-06 17:40:26 +00:00
|
|
|
|
);
|
|
|
|
|
window.console && window.console.log.apply(window.console, args);
|
2011-05-05 18:02:56 +00:00
|
|
|
|
return args.join(' ');
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.uid <f> Returns a unique id
|
|
|
|
|
() -> <n> Unique id
|
|
|
|
|
> Ox.uid() != Ox.uid()
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-05 18:02:56 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.uid = (function() {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var uid = 0;
|
|
|
|
|
return function() {
|
|
|
|
|
return uid++;
|
|
|
|
|
};
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.wrap <f> Wraps a value so that one can directly call any Ox function on it
|
|
|
|
|
(value) -> <o> wrapped value
|
|
|
|
|
chain <f> wrap the return value to allow chaining
|
2011-05-07 17:52:33 +00:00
|
|
|
|
value <f> unwrap the value wrapped by <code>chain()</chain>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.wrap("foobar").repeat(2)
|
|
|
|
|
"foobarfoobar"
|
|
|
|
|
> Ox.wrap("foobar").chain().reverse().toTitleCase().value()
|
|
|
|
|
"Raboof"
|
|
|
|
|
> Ox.wrap("foobar").value()
|
|
|
|
|
"foobar"
|
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.wrap = function(val, chained) {
|
2011-05-07 17:52:33 +00:00
|
|
|
|
// somewhat inspired by underscore.js
|
2011-05-07 15:56:29 +00:00
|
|
|
|
var wrapper = {
|
|
|
|
|
chain: function() {
|
|
|
|
|
wrapper.chained = true;
|
|
|
|
|
return wrapper;
|
|
|
|
|
},
|
|
|
|
|
chained: chained || false,
|
|
|
|
|
value: function() {
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
Object.getOwnPropertyNames(Ox).forEach(function(name) {
|
|
|
|
|
if (name[0] == name[0].toLowerCase() && Ox.isFunction(Ox[name])) {
|
|
|
|
|
wrapper[name] = function() {
|
|
|
|
|
var args = Array.prototype.slice.call(arguments), ret;
|
|
|
|
|
args.unshift(val);
|
|
|
|
|
ret = Ox[name].apply(Ox, args);
|
|
|
|
|
return wrapper.chained ? Ox.wrap(ret, true) : ret;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return wrapper;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//@ Array ----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
/*@
|
2011-05-07 21:07:53 +00:00
|
|
|
|
Ox.compact <f> Returns an array w/o <code>null</code> or <code>undefined</code>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.compact([null,,1,,2,,3])
|
|
|
|
|
[1, 2, 3]
|
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.compact = function(arr) {
|
|
|
|
|
/***
|
|
|
|
|
returns an array without null or undefined values
|
|
|
|
|
***/
|
|
|
|
|
return Ox.map(arr, function(val) {
|
|
|
|
|
return Ox.isUndefined(val) ? null : val;
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.flatten <f> Flattens an array
|
2011-05-07 21:07:53 +00:00
|
|
|
|
> Ox.flatten([1, [2, [3], 2], 1])
|
|
|
|
|
[1, 2, 3, 2, 1]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.flatten = function(arr) {
|
|
|
|
|
// fixme: can this work for objects too?
|
|
|
|
|
var ret = [];
|
|
|
|
|
arr.forEach(function(v) {
|
|
|
|
|
if (Ox.isArray(v)) {
|
|
|
|
|
Ox.flatten(v).forEach(function(v) {
|
|
|
|
|
ret.push(v);
|
|
|
|
|
});
|
|
|
|
|
} else {
|
|
|
|
|
ret.push(v);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.merge <f> Merges an array with one or more other arrays
|
2011-05-07 21:07:53 +00:00
|
|
|
|
> Ox.merge([1], [2, 3, 2], [1])
|
|
|
|
|
[1, 2, 3, 2, 1]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.merge = function(arr) {
|
|
|
|
|
Ox.forEach(Array.prototype.slice.call(arguments, 1), function(arg) {
|
|
|
|
|
Ox.forEach(arg, function(val) {
|
|
|
|
|
arr.push(val);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
return arr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.unique <f> Returns an array without duplicate values
|
|
|
|
|
> Ox.unique([1, 2, 3, 2, 1])
|
|
|
|
|
[1, 2, 3]
|
2011-05-05 18:02:56 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.unique = function(arr) {
|
|
|
|
|
var unique = [];
|
|
|
|
|
Ox.forEach(arr, function(val) {
|
|
|
|
|
unique.indexOf(val) == -1 && unique.push(val);
|
2011-04-27 19:39:56 +00:00
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
return unique;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.zip <f> Zips an array of arrays
|
|
|
|
|
> Ox.zip([[0, 1], [2, 3], [4, 5]])
|
|
|
|
|
[[0, 2, 4], [1, 3, 5]]
|
|
|
|
|
> Ox.zip([0, 1, 2], [3, 4, 5])
|
|
|
|
|
[[0, 3], [1, 4], [2, 5]]
|
|
|
|
|
@*/
|
|
|
|
|
Ox.zip = function() {
|
|
|
|
|
var args = arguments.length == 1 ? arguments[0] : Ox.makeArray(arguments),
|
|
|
|
|
arr = [];
|
|
|
|
|
args[0].forEach(function(v, i) {
|
|
|
|
|
arr[i] = [];
|
|
|
|
|
args.forEach(function(v_, i_) {
|
|
|
|
|
arr[i].push(v_[i]);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
return arr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//@ Collections ----------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
/*@
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.avg <f> Returns the average of an array's values, or an object's properties
|
|
|
|
|
(collection) -> <n> Average value
|
|
|
|
|
collection <[n]|o> Array or object with numerical values
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.avg([-1, 0, 1])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.avg({a: 1, b: 2, c: 3})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
2
|
2011-05-06 17:40:26 +00:00
|
|
|
|
@*/
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
Ox.avg = function(obj) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.sum(obj) / Ox.len(obj);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.clone <f> Returns a (shallow) copy or an object or array
|
|
|
|
|
> (function() { a = ['val']; b = Ox.clone(a); a[0] = null; return b[0]; }())
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'val'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> (function() { a = {key: 'val'}; b = Ox.clone(a); a.key = null; return b.key; }())
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'val'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.clone = function(obj) {
|
|
|
|
|
return Ox.isArray(obj) ? obj.slice() : Ox.extend({}, obj);
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.count <f> Counts the occurences of values in an array, object or string
|
|
|
|
|
> Ox.count(['f', 'o', 'o'])
|
|
|
|
|
{f: 1, o: 2}
|
|
|
|
|
> Ox.count({a: 'f', b: 'o', c: 'o'})
|
|
|
|
|
{f: 1, o: 2}
|
|
|
|
|
> Ox.count('foo')
|
|
|
|
|
{f: 1, o: 2}
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.count = function(arr) {
|
|
|
|
|
var obj = {};
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.forEach(arr, function(v) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
obj[v] = (obj[v] || 0) + 1;
|
|
|
|
|
});
|
|
|
|
|
return obj;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.each <f> (deprecated)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.each = function(obj, fn) {
|
|
|
|
|
// fixme: deprecate!
|
|
|
|
|
/*
|
|
|
|
|
Ox.each() works for arrays, objects and strings,
|
|
|
|
|
like $.each(), unlike [].forEach()
|
|
|
|
|
>>> Ox.each([0, 1, 2], function(i, v) {})
|
|
|
|
|
[0, 1, 2]
|
|
|
|
|
>>> Ox.each({a: 1, b: 2, c: 3}, function(k, v) {}).a
|
|
|
|
|
1
|
|
|
|
|
>>> Ox.each('foo', function(i, v) {})
|
|
|
|
|
'foo'
|
|
|
|
|
*/
|
|
|
|
|
var i, isArray = Ox.isArray(obj);
|
|
|
|
|
for (i in obj) {
|
|
|
|
|
i = isArray ? parseInt(i) : i;
|
|
|
|
|
// fixme: should be (v, k), like [].forEach()
|
|
|
|
|
if (fn(i, obj[i]) === false) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return obj;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.every <f> Returns true if a condition holds for every element of a collection
|
|
|
|
|
Unlike <code>[].every()</code>, <code>Ox.every()</code> works for arrays,
|
|
|
|
|
objects and strings.
|
|
|
|
|
> Ox.every([0, 1, 2], function(v, i) { return i == v; })
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.every({a: 1, b: 2, c: 3}, function(v) { return v == 1; })
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.every("foo", function(v) { return v == 'f'; })
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.every([true, true, true])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.every = function(obj, fn) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.filter(Ox.values(obj), fn || function(v) {
|
|
|
|
|
return v;
|
|
|
|
|
}).length == Ox.len(obj);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.filter <f> Filters a collection by a given condition
|
|
|
|
|
Unlike <code>[].filter()</code>, <code>Ox.filter()</code> works for arrays,
|
|
|
|
|
objects and strings.
|
|
|
|
|
> Ox.filter([2, 1, 0], function(v, i) { return v == i; })
|
|
|
|
|
[1]
|
|
|
|
|
> Ox.keys(Ox.filter({a: 'c', b: 'b', c: 'a'}, function(v, k) { return v == k; }))
|
|
|
|
|
['b']
|
|
|
|
|
> Ox.filter(' foo bar ', function(v) { return v != ' '; })
|
|
|
|
|
'foobar'
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
|
|
|
|
Ox.filter = function(obj, fn) {
|
|
|
|
|
var type = Ox.typeOf(obj),
|
|
|
|
|
ret = type == 'array' ? [] : type == 'object' ? {} : '';
|
|
|
|
|
Ox.forEach(obj, function(v, k) {
|
|
|
|
|
if (fn(v, k)) {
|
|
|
|
|
if (type == 'array') {
|
|
|
|
|
ret.push(v);
|
|
|
|
|
} else if (type == 'object') {
|
|
|
|
|
ret[k] = v;
|
|
|
|
|
} else {
|
|
|
|
|
ret += v;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.find <f> Returns array elements that match a string, leading matches first
|
|
|
|
|
> Ox.find(['foo', 'bar', 'foobar', 'barfoo'], 'foo')
|
2011-05-07 17:25:34 +00:00
|
|
|
|
[['foo', 'foobar'], ['barfoo']]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.find = function(arr, str) {
|
|
|
|
|
/*
|
|
|
|
|
returns an array with two arrays as elements:
|
|
|
|
|
an array of elements of arr that begin with str,
|
|
|
|
|
and an array of elements of arr that contain,
|
|
|
|
|
but do not begin with str
|
|
|
|
|
*/
|
|
|
|
|
var arrLowerCase = arr.map(function(v) {
|
|
|
|
|
return v.toLowerCase();
|
|
|
|
|
}),
|
|
|
|
|
ret = [[], []];
|
|
|
|
|
str && arrLowerCase.forEach(function(v, i) {
|
|
|
|
|
var index = v.indexOf(str.toLowerCase());
|
|
|
|
|
index > -1 && ret[index == 0 ? 0 : 1].push(arr[i]);
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.forEach <f> forEach loop
|
|
|
|
|
<code>Ox.forEach()</code> loops over arrays, objects and strings.
|
|
|
|
|
Returning <code>false</code> from the iterator function acts like a
|
|
|
|
|
<code>break</code> statement (unlike <code>[].forEach()</code>, like
|
|
|
|
|
<code>$.each()</code>). The arguments of the iterator function are
|
|
|
|
|
<code>(value, key)</code> (like <code>[].forEach()</code>, unlike
|
|
|
|
|
<code>$.each()</code>).
|
|
|
|
|
(collection, callback) <a|o|s> The collection
|
|
|
|
|
collection <a|o|s> An array, object or string
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
value <*> Value
|
|
|
|
|
key <n|s> Key
|
2011-05-07 17:25:34 +00:00
|
|
|
|
<script>
|
|
|
|
|
Ox.test.string = "";
|
|
|
|
|
Ox.forEach(["f", "o", "o"], function(v, i) { Ox.test.string += i; });
|
|
|
|
|
Ox.forEach({a: "f", b: "o", c: "o"}, function(v, k) { Ox.test.string += k; });
|
|
|
|
|
Ox.forEach("foo", function(v) { Ox.test.string += v; });
|
|
|
|
|
</script>
|
2011-05-06 23:30:32 +00:00
|
|
|
|
> Ox.test.string
|
|
|
|
|
"012abcfoo"
|
2011-05-07 17:25:34 +00:00
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.forEach = function(obj, fn) {
|
|
|
|
|
var isObject = Ox.isObject(obj), key;
|
|
|
|
|
for (key in obj) {
|
|
|
|
|
key = isObject ? key : parseInt(key);
|
|
|
|
|
if (/*hasOwnProperty.call(obj, key) && */fn(obj[key], key) === false) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return obj;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getObjectById <f> Returns an array element with a given id
|
|
|
|
|
@*/
|
|
|
|
|
// fixme: shouldn't this be getElementById() ?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getObjectById = function(arr, id) {
|
|
|
|
|
/***
|
|
|
|
|
>>> Ox.getObjectById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "foo").title
|
|
|
|
|
"Foo"
|
|
|
|
|
***/
|
|
|
|
|
var ret = null;
|
|
|
|
|
Ox.forEach(arr, function(v) {
|
|
|
|
|
if (v.id == id) {
|
|
|
|
|
ret = v;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getPositionById <f> Returns the index of an array element with a given id
|
|
|
|
|
@*/
|
|
|
|
|
// fixme: shouldn't this be getIndexById() ?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getPositionById = function(arr, id) {
|
|
|
|
|
/***
|
|
|
|
|
>>> Ox.getPositionById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "bar")
|
|
|
|
|
1
|
|
|
|
|
***/
|
|
|
|
|
var ret = -1;
|
|
|
|
|
Ox.forEach(arr, function(v, i) {
|
|
|
|
|
if (v.id == id) {
|
|
|
|
|
ret = i;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// fixme: and what about getElementBy() and getIndexBy() ?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getset <f> Generic getter and setter function
|
|
|
|
|
See examples for details.
|
|
|
|
|
# Usage --------------------------------------------------------------------
|
|
|
|
|
Ox.getset(options, args=[]) -> <o> all options
|
|
|
|
|
Ox.getset(options, args=[key]) -> <*> options[key]
|
|
|
|
|
Ox.getset(options, args=[key, value], callback, context) -> <f|o> context
|
|
|
|
|
sets options[key] to value and calls fn(key, value)
|
|
|
|
|
if the key/value pair was added or modified
|
|
|
|
|
Ox.getset(options, args=[{key: value}], callback, context) -> <f|o> context
|
|
|
|
|
sets multiple options and calls fn(key, value)
|
|
|
|
|
for every key/value pair that was added or modified
|
|
|
|
|
# Arguments ----------------------------------------------------------------
|
|
|
|
|
options <obj> Options object (key/value pairs)
|
|
|
|
|
args <arr> The arguments "array" of the caller function
|
|
|
|
|
callback <fun> Callback function
|
|
|
|
|
The callback is called for every key/value pair that was added or
|
|
|
|
|
modified.
|
|
|
|
|
key <s> Key
|
|
|
|
|
value <*> Value
|
|
|
|
|
context <obj> The parent object of the caller function (for chaining)
|
|
|
|
|
# Examples -----------------------------------------------------------------
|
|
|
|
|
<script>
|
|
|
|
|
Ox.test.object = new function() {
|
|
|
|
|
var options = {},
|
|
|
|
|
setOption = function(key, value) {},
|
|
|
|
|
that = this;
|
|
|
|
|
that.options = function() {
|
|
|
|
|
return Ox.getset(options, arguments, setOption, that);
|
|
|
|
|
};
|
|
|
|
|
return that;
|
|
|
|
|
};
|
|
|
|
|
</script>
|
|
|
|
|
> Ox.test.object.options("key", "val").options("key")
|
|
|
|
|
"val"
|
|
|
|
|
> Ox.test.object.options({foo: "foo", bar: "bar"}).options()
|
|
|
|
|
{"key": "val", "foo": "foo", "bar": "bar"}
|
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.getset = function(obj, args, callback, context) {
|
|
|
|
|
var obj_ = Ox.clone(obj), ret;
|
|
|
|
|
if (args.length == 0) {
|
|
|
|
|
// getset([])
|
|
|
|
|
ret = obj;
|
|
|
|
|
} else if (args.length == 1 && !Ox.isObject(args[0])) {
|
|
|
|
|
// getset([key])
|
|
|
|
|
ret = obj[args[0]];
|
|
|
|
|
} else {
|
|
|
|
|
// getset([key, val]) or getset([{key: val, ...}])
|
|
|
|
|
args = Ox.makeObject(args);
|
|
|
|
|
obj = Ox.extend(obj, args);
|
|
|
|
|
Ox.forEach(args, function(val, key) {
|
|
|
|
|
if (!obj_ || !Ox.isEqual(obj_[key], val)) {
|
|
|
|
|
callback && callback(key, val);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
ret = context;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.isEmpty <f> Returns true if an array, object or string is empty
|
|
|
|
|
> Ox.isEmpty([])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.isEmpty({})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.isEmpty('')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isEmpty = function(val) {
|
|
|
|
|
return Ox.len(val) == 0;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.keys <f> Returns the keys of an array, object or string
|
|
|
|
|
Unlike <code>Object.keys()</code>, <code>Ox.keys()</code> works for arrays,
|
|
|
|
|
objects and strings.
|
|
|
|
|
> Ox.keys([1, 2, 3])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 1, 2]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.keys([1,,3])
|
|
|
|
|
[0, 2]
|
|
|
|
|
> Ox.keys([,])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.keys({a: 1, b: 2, c: 3})
|
|
|
|
|
['a', 'b', 'c']
|
|
|
|
|
> Ox.keys('abc')
|
|
|
|
|
[0, 1, 2]
|
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
// fixme: is this really needed? arrays... ok... but strings??
|
|
|
|
|
|
|
|
|
|
Ox.keys = function(obj) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var keys = [];
|
|
|
|
|
Ox.forEach(obj, function(v, k) {
|
|
|
|
|
keys.push(k);
|
|
|
|
|
});
|
|
|
|
|
return keys.sort();
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.last <f> Gets or sets the last element of an array
|
|
|
|
|
Unlike <code>foobarbaz[foobarbaz.length - 1]</code>,
|
|
|
|
|
<code>Ox.last(foobarbaz)</code> is short.
|
2011-05-07 17:25:34 +00:00
|
|
|
|
<script>
|
|
|
|
|
Ox.test.array = [1, 2, 3];
|
|
|
|
|
</script>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.last(Ox.test.array)
|
2011-04-29 12:40:51 +00:00
|
|
|
|
3
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.last(Ox.test.array, 4)
|
2011-04-29 12:40:51 +00:00
|
|
|
|
[1, 2, 4]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.test.array
|
|
|
|
|
[1, 2, 4]
|
|
|
|
|
@*/
|
|
|
|
|
Ox.last = function(arr, val) {
|
2011-04-29 12:40:51 +00:00
|
|
|
|
var ret;
|
|
|
|
|
if (arguments.length == 1) {
|
|
|
|
|
ret = arr[arr.length - 1];
|
|
|
|
|
} else {
|
|
|
|
|
arr[arr.length - 1] = val;
|
|
|
|
|
ret = arr;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.len <f> Returns the length of an array, function, object or string
|
|
|
|
|
Not to be confused with <code>Ox.length</code>, which is the
|
|
|
|
|
<code>length</code> property of the <code>Ox</code> function
|
|
|
|
|
(<code>1</code).
|
|
|
|
|
> Ox.len([1, 2, 3])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
3
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.len([,])
|
|
|
|
|
1
|
|
|
|
|
> Ox.len({a: 1, b: 2, c: 3})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
3
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.len(function(x, y, z) { return x + y + z; })
|
2011-04-27 19:39:56 +00:00
|
|
|
|
3
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.len('abc')
|
|
|
|
|
3
|
|
|
|
|
@*/
|
|
|
|
|
Ox.len = function(obj) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.isObject(obj) ? Ox.values(obj).length : obj.length;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.loop <f> For-loop, functional-style
|
|
|
|
|
Returning <code>false</code> from the iterater function acts like a
|
|
|
|
|
<code>break</code> statement. Unlike a <code>for</code> loop,
|
|
|
|
|
<code>Ox.loop</code> doesn't leak its counter variable to the outer scope,
|
|
|
|
|
but returns it.
|
|
|
|
|
(stop, callback) -> <n> Next value
|
|
|
|
|
equivalent to <code>for (var i = 0; i < stop; i++)</code>
|
|
|
|
|
(start, stop, callback) -> <n> Next value
|
|
|
|
|
equivalent to <code>for (var i = start; i < stop; i++)</code> or,
|
|
|
|
|
if <code>start</code> is larger than <code>stop</code>,
|
|
|
|
|
<code>for (var i = start; i > stop; i--)</code>
|
|
|
|
|
(start, stop, step) -> <n> Next value
|
|
|
|
|
equivalent to <code>for (var i = start; i < stop; i += step)</code>
|
|
|
|
|
start <n> Start value
|
|
|
|
|
stop <n> Stop value (exclusive)
|
|
|
|
|
step <n> Step value
|
|
|
|
|
callback <f> Iterator function
|
|
|
|
|
i <n> Counter value
|
|
|
|
|
> Ox.loop(0, 3, 2, function() {})
|
|
|
|
|
4
|
|
|
|
|
> Ox.loop(10, function(i) { return i != 4; })
|
|
|
|
|
4
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.loop = function() {
|
|
|
|
|
var length = arguments.length,
|
|
|
|
|
start = length > 2 ? arguments[0] : 0,
|
2011-05-06 22:47:17 +00:00
|
|
|
|
stop = arguments[length > 2 ? 1 : 0],
|
|
|
|
|
step = length == 4 ? arguments[2] : (start <= stop ? 1 : -1),
|
|
|
|
|
callback = arguments[length - 1],
|
2011-04-27 19:39:56 +00:00
|
|
|
|
i;
|
2011-05-06 22:47:17 +00:00
|
|
|
|
for (i = start; step > 0 ? i < stop : i > stop; i += step) {
|
|
|
|
|
if (callback(i) === false) {
|
|
|
|
|
break;
|
|
|
|
|
};
|
2011-04-27 19:39:56 +00:00
|
|
|
|
}
|
2011-05-06 22:47:17 +00:00
|
|
|
|
return i;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.makeArray <f> Takes an array-like object and returns a true array
|
|
|
|
|
Alias for <code>Array.prototype.slice.call</code>
|
|
|
|
|
(value) -> <a> True array
|
|
|
|
|
value <*> Array-like object
|
|
|
|
|
> (function() { return Ox.makeArray(arguments); }("foo", "bar"))
|
|
|
|
|
["foo", "bar"]
|
|
|
|
|
> Ox.makeArray("foo")
|
|
|
|
|
["f", "o", "o"]
|
2011-05-06 23:30:32 +00:00
|
|
|
|
> Ox.makeArray({0: "f", 1: "o", 2: "o", length: 3})
|
2011-05-06 22:47:17 +00:00
|
|
|
|
["f", "o", "o"]
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.makeArray = function(obj) {
|
|
|
|
|
return Array.prototype.slice.call(obj);
|
|
|
|
|
}
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.makeObject <f> Takes an array and returns an object
|
|
|
|
|
<code>Ox.makeObject</code> is a helper for functions with two alternative
|
|
|
|
|
signatures like <code>('key', 'val')</code> and <code>({key: 'val'})</code>.
|
|
|
|
|
> (function() { return Ox.makeObject(arguments); }({foo: 1, bar: 2}))
|
|
|
|
|
{foo: 1, bar: 2}
|
|
|
|
|
> (function() { return Ox.makeObject(arguments); }('foo', 1))
|
|
|
|
|
{foo: 1}
|
|
|
|
|
> (function() { return Ox.makeObject(arguments); }('foo'))
|
|
|
|
|
{}
|
|
|
|
|
> (function() { return Ox.makeObject(arguments); }())
|
|
|
|
|
{}
|
|
|
|
|
@*/
|
2011-04-29 22:07:23 +00:00
|
|
|
|
Ox.makeObject = function(obj) {
|
|
|
|
|
var ret = {};
|
2011-04-29 22:56:46 +00:00
|
|
|
|
if (Ox.isObject(obj[0])) {
|
2011-04-29 22:07:23 +00:00
|
|
|
|
// ({foo: 'bar'})
|
|
|
|
|
ret = obj[0];
|
2011-04-29 22:56:46 +00:00
|
|
|
|
} else if (obj.length) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
// ('foo', 'bar')
|
2011-04-29 22:07:23 +00:00
|
|
|
|
ret[obj[0]] = obj[1]
|
2011-04-27 19:39:56 +00:00
|
|
|
|
}
|
2011-04-29 22:07:23 +00:00
|
|
|
|
return ret;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 17:25:34 +00:00
|
|
|
|
/*@
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.map <f> Transforms the values of an array, object or string
|
|
|
|
|
Unlike <code>[].map()</code>, <code>Ox.map()</code> works for arrays,
|
|
|
|
|
objects and strings. Returning <code>null</code> from the iterator
|
|
|
|
|
function will remove the element from the collection.
|
|
|
|
|
> Ox.map([0, 0, 0], function(v, i) { return v == i; })
|
|
|
|
|
[true, false, false]
|
|
|
|
|
> Ox.map({a: 'a', b: 'a', c: 'a'}, function(v, k) { return v == k; })
|
|
|
|
|
{a: true, b: false, c: false}
|
|
|
|
|
> Ox.map("000", function(v, i) { return v == i; })
|
|
|
|
|
[true, false, false]
|
|
|
|
|
> Ox.map([0, 1, 2, 4], function(v, i) { return v ? i == v : null; })
|
|
|
|
|
[true, true, false]
|
|
|
|
|
> Ox.map([,], function(v, i) { return i; })
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0]
|
2011-05-07 17:25:34 +00:00
|
|
|
|
@*/
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
|
|
|
|
Ox.map = function(obj, fn) {
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// fixme: return null to filter out is a bit esoteric
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var isObject = Ox.isObject(obj),
|
|
|
|
|
ret = isObject ? {} : [];
|
|
|
|
|
Ox.forEach(obj, function(val, key) {
|
|
|
|
|
if ((v = fn(val, key)) !== null) {
|
|
|
|
|
ret[isObject ? key : ret.length] = v;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.max <f> Returns the maximum value of a collection
|
|
|
|
|
> Ox.max([1, 2, 3])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
3
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.max({a: 1, b: 2, c: 3})
|
|
|
|
|
3
|
|
|
|
|
> Ox.max('123')
|
|
|
|
|
3
|
|
|
|
|
@*/
|
|
|
|
|
Ox.max = function(obj) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Math.max.apply(Math, Ox.values(obj));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.min <f> Returns the minimum value of a collection
|
|
|
|
|
> Ox.min([1, 2, 3])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.min({a: 1, b: 2, c: 3})
|
|
|
|
|
1
|
|
|
|
|
> Ox.min('123')
|
|
|
|
|
1
|
|
|
|
|
@*/
|
|
|
|
|
Ox.min = function(obj) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Math.min.apply(Math, Ox.values(obj));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.range <f> Python-style range
|
|
|
|
|
(stop) -> <[n]> range
|
|
|
|
|
Returns an array of integers from <code>0</code> (inclusive) to
|
|
|
|
|
<code>stop</code> (exclusive).
|
|
|
|
|
(start, stop) -> <[n]> range
|
|
|
|
|
Returns an array of integers from <code>start</code> (inclusive) to
|
|
|
|
|
<code>stop</code> (exclusive).
|
|
|
|
|
(start, stop, step) -> <[n]> range
|
|
|
|
|
Returns an array of numbers from <code>start</code> (inclusive) to
|
|
|
|
|
<code>stop</code> (exclusive), incrementing by <code>step</step>.
|
|
|
|
|
start <n> Start value
|
|
|
|
|
stop <n> Stop value
|
|
|
|
|
step <n> Step value
|
|
|
|
|
> Ox.range(3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 1, 2]
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.range(1, 4)
|
|
|
|
|
[1, 2, 3]
|
|
|
|
|
> Ox.range(3, 0)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[3, 2, 1]
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.range(1, 2, 0.5)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[1, 1.5]
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.range(-1, -2, -0.5)
|
|
|
|
|
[-1, -1.5]
|
|
|
|
|
@*/
|
|
|
|
|
Ox.range = function() {
|
|
|
|
|
var args = Ox.makeArray(arguments),
|
|
|
|
|
arr = [];
|
|
|
|
|
args.push(function(i) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
arr.push(i);
|
2011-05-06 22:47:17 +00:00
|
|
|
|
});
|
|
|
|
|
Ox.loop.apply(null, args);
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return arr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.serialize = function(obj) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.serialize({a: 1, b: 2, c: 3})
|
|
|
|
|
'a=1&b=2&c=3'
|
|
|
|
|
*/
|
|
|
|
|
var arr = [];
|
|
|
|
|
Ox.forEach(obj, function(val, key) {
|
|
|
|
|
val !== '' && arr.push(key + '=' + val);
|
|
|
|
|
});
|
|
|
|
|
return arr.join('&');
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.setPropertyOnce = function(arr, str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.setPropertyOnce([{selected: false}, {selected: false}], 'selected')
|
|
|
|
|
0
|
|
|
|
|
>>> Ox.setPropertyOnce([{selected: false}, {selected: true}], 'selected')
|
|
|
|
|
1
|
|
|
|
|
>>> Ox.setPropertyOnce([{selected: true}, {selected: true}], 'selected')
|
|
|
|
|
0
|
|
|
|
|
*/
|
|
|
|
|
var pos = -1;
|
|
|
|
|
Ox.forEach(arr, function(v, i) {
|
|
|
|
|
if (pos == -1 && arr[i][str]) {
|
|
|
|
|
pos = i;
|
|
|
|
|
} else if (pos > -1 && arr[i][str]) {
|
|
|
|
|
delete arr[i][str];
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
if (pos == -1) {
|
|
|
|
|
arr[0][str] = true;
|
|
|
|
|
pos = 0;
|
|
|
|
|
}
|
|
|
|
|
return pos;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.shuffle = function(arr) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.shuffle([1, 2, 3]).length
|
|
|
|
|
3
|
|
|
|
|
*/
|
|
|
|
|
var shuffle = arr;
|
|
|
|
|
return shuffle.sort(function() {
|
|
|
|
|
return Math.random() - 0.5;
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.some = function(obj, fn) {
|
|
|
|
|
/*
|
|
|
|
|
Ox.some() works for arrays, objects and strings, unlike [].some()
|
|
|
|
|
>>> Ox.some([2, 1, 0], function(i, v) { return i == v; })
|
|
|
|
|
true
|
|
|
|
|
>>> Ox.some({a: 1, b: 2, c: 3}, function(v) { return v == 1; })
|
|
|
|
|
true
|
|
|
|
|
>>> Ox.some("foo", function(v) { return v == 'f'; })
|
|
|
|
|
true
|
|
|
|
|
*/
|
|
|
|
|
return Ox.filter(Ox.values(obj), fn).length > 0;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.sort = function(arr) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.sort(['10', '9', 'B', 'a'])
|
|
|
|
|
['9', '10', 'a', 'B']
|
|
|
|
|
*/
|
|
|
|
|
var len, matches = {}, sort = {};
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// find leading numbers
|
2011-04-27 19:39:56 +00:00
|
|
|
|
arr.forEach(function(val, i) {
|
|
|
|
|
var match = /^\d+/(val);
|
|
|
|
|
matches[val] = match ? match[0] : '';
|
|
|
|
|
});
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// get length of longest leading number
|
2011-04-27 19:39:56 +00:00
|
|
|
|
len = Ox.max(Ox.map(matches, function(val) {
|
|
|
|
|
return val.length;
|
|
|
|
|
}));
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// pad leading numbers, and make lower case
|
2011-04-27 19:39:56 +00:00
|
|
|
|
arr.forEach(function(val) {
|
|
|
|
|
sort[val] = (
|
|
|
|
|
matches[val] ?
|
|
|
|
|
Ox.pad(matches[val], len) + val.toString().substr(matches[val].length) :
|
|
|
|
|
val
|
|
|
|
|
).toLowerCase();
|
|
|
|
|
});
|
|
|
|
|
return arr.sort(function(a, b) {
|
|
|
|
|
var ret = 0;
|
|
|
|
|
if (sort[a] < sort[b]) {
|
|
|
|
|
ret = -1;
|
|
|
|
|
} else if (sort[a] > sort[b]) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.sum = function(obj) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.sum([-1, 0, 1])
|
|
|
|
|
0
|
|
|
|
|
>>> Ox.sum({a: 1, b: 2, c: 3})
|
|
|
|
|
6
|
|
|
|
|
*/
|
|
|
|
|
var sum = 0;
|
|
|
|
|
Ox.forEach(obj, function(val) {
|
|
|
|
|
sum += val;
|
|
|
|
|
});
|
|
|
|
|
return sum;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.toArray = function(obj) {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
// fixme: can this be thrown out?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toArray('foo')
|
|
|
|
|
['foo']
|
|
|
|
|
>>> Ox.toArray(['foo'])
|
|
|
|
|
['foo']
|
|
|
|
|
*/
|
|
|
|
|
var arr;
|
|
|
|
|
if (Ox.isArray(obj)) {
|
|
|
|
|
arr = obj;
|
|
|
|
|
} else if (Ox.isArguments(obj)) {
|
|
|
|
|
arr = Ox.makeArray(obj);
|
|
|
|
|
} else {
|
|
|
|
|
arr = [obj];
|
|
|
|
|
}
|
|
|
|
|
return arr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.unserialize = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.unserialize('a=1&b=2&c=3').c
|
|
|
|
|
'3'
|
|
|
|
|
*/
|
|
|
|
|
var arr, obj = {};
|
|
|
|
|
Ox.forEach(str.split('&'), function(val) {
|
|
|
|
|
arr = val.split('=');
|
|
|
|
|
obj[arr[0]] = arr[1];
|
|
|
|
|
});
|
|
|
|
|
return obj;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.values = function(obj) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.values([1, 2, 3])
|
|
|
|
|
[1, 2, 3]
|
|
|
|
|
>>> Ox.values({a: 1, b: 2, c: 3})
|
|
|
|
|
[1, 2, 3]
|
|
|
|
|
>>> Ox.values('abc')
|
|
|
|
|
['a', 'b', 'c']
|
|
|
|
|
>>> Ox.values([1,])
|
|
|
|
|
[1]
|
|
|
|
|
*/
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// fixme: why doesn't this use map?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var values = [];
|
|
|
|
|
Ox.forEach(obj, function(val) {
|
|
|
|
|
values.push(val);
|
|
|
|
|
});
|
|
|
|
|
return values;
|
|
|
|
|
};
|
|
|
|
|
|
2011-04-29 14:56:40 +00:00
|
|
|
|
Ox.walk = function(obj, fn) {
|
|
|
|
|
/*
|
|
|
|
|
>>> a = 0; Ox.walk({a: 1, b: {c: 2, d: 3}}, function(v, k) { a += Ox.isNumber(v) ? v : 0}); a
|
|
|
|
|
6
|
|
|
|
|
*/
|
|
|
|
|
Ox.forEach(obj, function(val, key) {
|
|
|
|
|
fn(val, key, obj);
|
|
|
|
|
Ox.walk(obj[key], fn);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Color ----------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.hsl <f> Takes RGB values and returns HSL values
|
|
|
|
|
(rgb) <[n]> HSL values
|
|
|
|
|
rgb <[n]> RGB values
|
|
|
|
|
> Ox.hsl([0, 0, 0])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 0, 0]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.hsl([255, 255, 255])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 0, 1]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.hsl([0, 255, 0])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[120, 1, 0.5]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.hsl = function(rgb) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
rgb = rgb.map(function(v) {
|
|
|
|
|
return v / 255;
|
|
|
|
|
});
|
|
|
|
|
var max = Ox.max(rgb),
|
|
|
|
|
min = Ox.min(rgb),
|
|
|
|
|
hsl = [0, 0, 0];
|
|
|
|
|
hsl[2] = 0.5 * (max + min);
|
|
|
|
|
if (max == min) {
|
|
|
|
|
hsl[0] = 0;
|
|
|
|
|
hsl[1] = 0;
|
|
|
|
|
} else {
|
|
|
|
|
if (max == rgb[0]) {
|
|
|
|
|
hsl[0] = (60 * (rgb[1] - rgb[2]) / (max - min) + 360) % 360;
|
|
|
|
|
} else if (max == rgb[1]) {
|
|
|
|
|
hsl[0] = 60 * (rgb[2] - rgb[0]) / (max - min) + 120;
|
|
|
|
|
} else if (max == rgb[2]) {
|
|
|
|
|
hsl[0] = 60 * (rgb[0] - rgb[1]) / (max - min) + 240;
|
|
|
|
|
}
|
|
|
|
|
if (hsl[2] <= 0.5) {
|
|
|
|
|
hsl[1] = (max - min) / (2 * hsl[2]);
|
|
|
|
|
} else {
|
|
|
|
|
hsl[1] = (max - min) / (2 - 2 * hsl[2]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return hsl;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.rgb <f> Takes HSL values and returns RGB values
|
|
|
|
|
(hsl) <[n]> RGB values
|
|
|
|
|
hsl <[n]> HSL values
|
|
|
|
|
> Ox.rgb([0, 0, 0])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 0, 0]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.rgb([0, 0, 1])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[255, 255, 255]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.rgb([120, 1, 0.5])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[0, 255, 0]
|
2011-05-06 17:40:26 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.rgb = function(hsl) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
hsl[0] /= 360;
|
|
|
|
|
var rgb = [0, 0, 0],
|
|
|
|
|
v1, v2, v3;
|
|
|
|
|
if (hsl[1] == 0) {
|
|
|
|
|
rgb = [hsl[2], hsl[2], hsl[2]];
|
|
|
|
|
} else {
|
|
|
|
|
if (hsl[2] < 0.5) {
|
|
|
|
|
v2 = hsl[2] * (1 + hsl[1]);
|
|
|
|
|
} else {
|
|
|
|
|
v2 = hsl[1] + hsl[2] - (hsl[1] * hsl[2]);
|
|
|
|
|
}
|
|
|
|
|
v1 = 2 * hsl[2] - v2;
|
|
|
|
|
rgb.forEach(function(v, i) {
|
|
|
|
|
v3 = hsl[0] + (1 - i) * 1/3;
|
|
|
|
|
if (v3 < 0) {
|
|
|
|
|
v3++;
|
|
|
|
|
} else if (v3 > 1) {
|
|
|
|
|
v3--;
|
|
|
|
|
}
|
|
|
|
|
if (v3 < 1/6) {
|
|
|
|
|
rgb[i] = v1 + ((v2 - v1) * 6 * v3);
|
|
|
|
|
} else if (v3 < 0.5) {
|
|
|
|
|
rgb[i] = v2;
|
|
|
|
|
} else if (v3 < 2/3) {
|
|
|
|
|
rgb[i] = v1 + ((v2 - v1) * 6 * (2/3 - v3));
|
|
|
|
|
} else {
|
|
|
|
|
rgb[i] = v1;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
return rgb.map(function(v) {
|
|
|
|
|
return v * 255;
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Constants ------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
//@ Ox.AMPM <[str]> ['AM', 'PM']
|
|
|
|
|
Ox.AMPM = ['AM', 'PM'];
|
|
|
|
|
//@ Ox.DURATIONS <[str]> ['year', 'month', 'day', 'minute', 'second']
|
|
|
|
|
Ox.DURATIONS = ['year', 'month', 'day', 'minute', 'second'];
|
|
|
|
|
//@ Ox.EARTH_RADIUS <number> Radius of the earth in meters
|
|
|
|
|
// see http://en.wikipedia.org/wiki/WGS-84
|
|
|
|
|
Ox.EARTH_RADIUS = 6378137;
|
|
|
|
|
//@ Ox.EARTH_CIRCUMFERENCE <num> Circumference of the earth in meters
|
|
|
|
|
Ox.EARTH_CIRCUMFERENCE = Ox.EARTH_RADIUS * 2 * Math.PI;
|
|
|
|
|
//@ Ox.HTML_ENTITIES <object> HTML entities for ... (FIXME)
|
|
|
|
|
Ox.HTML_ENTITIES = {
|
|
|
|
|
'"': '"', '&': '&', "'": ''', '<': '<', '>': '>'
|
|
|
|
|
};
|
|
|
|
|
//@ Ox.KEYS <object> Names for key codes
|
|
|
|
|
// The dot notation ('0.numpad') allows for namespaced events ('key_0.numpad'),
|
|
|
|
|
// so that binding to 'key_0' will catch both 'key_0' and 'key_0.numpad'.
|
|
|
|
|
Ox.KEYS = {
|
|
|
|
|
0: 'section', 8: 'backspace', 9: 'tab', 12: 'clear', 13: 'enter',
|
|
|
|
|
16: 'shift', 17: 'control', 18: 'alt', 20: 'capslock', 27: 'escape',
|
|
|
|
|
32: 'space', 33: 'pageup', 34: 'pagedown', 35: 'end', 36: 'home',
|
|
|
|
|
37: 'left', 38: 'up', 39: 'right', 40: 'down',
|
|
|
|
|
45: 'insert', 46: 'delete', 47: 'help',
|
|
|
|
|
48: '0', 49: '1', 50: '2', 51: '3', 52: '4',
|
|
|
|
|
53: '5', 54: '6', 55: '7', 56: '8', 57: '9',
|
|
|
|
|
65: 'a', 66: 'b', 67: 'c', 68: 'd', 69: 'e',
|
|
|
|
|
70: 'f', 71: 'g', 72: 'h', 73: 'i', 74: 'j',
|
|
|
|
|
75: 'k', 76: 'l', 77: 'm', 78: 'n', 79: 'o',
|
|
|
|
|
80: 'p', 81: 'q', 82: 'r', 83: 's', 84: 't',
|
|
|
|
|
85: 'u', 86: 'v', 87: 'w', 88: 'x', 89: 'y', 90: 'z',
|
|
|
|
|
// fixme: this is usually 91: window.left, 92: window.right, 93: select
|
|
|
|
|
91: 'meta.left', 92: 'meta.right', 93: 'meta.right',
|
|
|
|
|
96: '0.numpad', 97: '1.numpad', 98: '2.numpad',
|
|
|
|
|
99: '3.numpad', 100: '4.numpad', 101: '5.numpad',
|
|
|
|
|
102: '6.numpad', 103: '7.numpad', 104: '8.numpad', 105: '9.numpad',
|
|
|
|
|
106: 'asterisk.numpad', 107: 'plus.numpad', 109: 'minus.numpad',
|
|
|
|
|
108: 'enter.numpad', 110: 'dot.numpad', 111: 'slash.numpad',
|
|
|
|
|
112: 'f1', 113: 'f2', 114: 'f3', 115: 'f4', 116: 'f5',
|
|
|
|
|
117: 'f6', 118: 'f7', 119: 'f8', 120: 'f9', 121: 'f10',
|
|
|
|
|
122: 'f11', 123: 'f12', 124: 'f13', 125: 'f14', 126: 'f15', 127: 'f16',
|
|
|
|
|
144: 'numlock', 145: 'scrolllock',
|
|
|
|
|
186: 'semicolon', 187: 'equal', 188: 'comma', 189: 'minus',
|
|
|
|
|
190: 'dot', 191: 'slash', 192: 'backtick', 219: 'openbracket',
|
|
|
|
|
220: 'backslash', 221: 'closebracket', 222: 'quote', 224: 'meta'
|
|
|
|
|
// see dojo, for ex.
|
|
|
|
|
},
|
|
|
|
|
Ox.MAP_TILE_SIZE = 256; // fixme: definitely not needed here
|
|
|
|
|
//@ Ox.MODIFIER_KEYS <obj> Names for modifier keys
|
|
|
|
|
// meta comes last so that one can differentiate between
|
|
|
|
|
// alt_control_shift_meta.left and alt_control_shift_meta.right
|
|
|
|
|
Ox.MODIFIER_KEYS = {
|
|
|
|
|
altKey: 'alt', // Mac: option
|
|
|
|
|
ctrlKey: 'control',
|
|
|
|
|
shiftKey: 'shift',
|
|
|
|
|
metaKey: 'meta', // Mac: command
|
|
|
|
|
}
|
|
|
|
|
//@ Ox.MONTHS <[str]> Names of months
|
|
|
|
|
Ox.MONTHS = [
|
|
|
|
|
'January', 'February', 'March', 'April', 'May', 'June',
|
|
|
|
|
'July', 'August', 'September', 'October', 'November', 'December'
|
|
|
|
|
];
|
|
|
|
|
//@ Ox.SHORT_MONTHS <[str]> Short names of months
|
|
|
|
|
Ox.SHORT_MONTHS = Ox.MONTHS.map(function(val) {
|
|
|
|
|
return val.substr(0, 3);
|
|
|
|
|
});
|
|
|
|
|
//@ Ox.PATH <str> Path of Ox.js
|
|
|
|
|
Ox.PATH = Array.prototype.slice.apply(
|
|
|
|
|
document.getElementsByTagName('script')
|
|
|
|
|
).filter(function(element) {
|
|
|
|
|
return /Ox\.js$/.test(element.src);
|
|
|
|
|
})[0].src.replace('Ox.js', '');
|
|
|
|
|
//@ Ox.PREFIXES <[str]> <code>['K', 'M', 'G', 'T', 'P']</code>
|
|
|
|
|
Ox.PREFIXES = ['K', 'M', 'G', 'T', 'P'];
|
|
|
|
|
//@ Ox.SYMBOLS <obj> Unicode characters for symbols
|
|
|
|
|
Ox.SYMBOLS = {
|
|
|
|
|
DOLLAR: '\u0024',
|
|
|
|
|
CENT: '\u00A2', POUND: '\u00A3', CURRENCY: '\u00A4', YEN: '\u00A5',
|
|
|
|
|
BULLET: '\u2022', ELLIPSIS: '\u2026', PERMILLE: '\u2030',
|
|
|
|
|
COLON: '\u20A1', CRUZEIRO: '\u20A2', FRANC: '\u20A3', LIRA: '\u20A4',
|
|
|
|
|
NAIRA: '\u20A6', PESETA: '\u20A7', WON: '\u20A9', SHEQEL: '\u20AA',
|
|
|
|
|
DONG: '\u20AB', EURO: '\u20AC', KIP: '\u20AD', TUGRIK: '\u20AE',
|
|
|
|
|
DRACHMA: '\u20AF', PESO: '\u20B1', GUARANI: '\u20B2', AUSTRAL: '\u20B3',
|
|
|
|
|
HRYVNIA: '\u20B4', CEDI: '\u20B5', TENGE: '\u20B8', RUPEE: '\u20B9',
|
|
|
|
|
CELSIUS: '\u2103', FAHRENHEIT: '\u2109', POUNDS: '\u2114', OUNCE: '\u2125',
|
|
|
|
|
OHM: '\u2126', KELVIN: '\u212A', ANGSTROM: '\u212B', INFO: '\u2139',
|
|
|
|
|
LEFT: '\u2190', UP: '\u2191', RIGHT: '\u2192', DOWN: '\u2193',
|
|
|
|
|
HOME: '\u2196', END: '\u2198', RETURN: '\u21A9',
|
|
|
|
|
REDO: '\u21BA', UNDO: '\u21BB', PAGEUP: '\u21DE', PAGEDOWN: '\u21DF',
|
|
|
|
|
CAPSLOCK: '\u21EA', TAB: '\u21E5', SHIFT: '\u21E7', INFINITY: '\u221E',
|
|
|
|
|
CONTROL: '\u2303', COMMAND: '\u2318', ENTER: '\u2324', ALT: '\u2325',
|
|
|
|
|
DELETE: '\u2326', CLEAR:'\u2327',BACKSPACE: '\u232B', OPTION: '\u2387',
|
|
|
|
|
NAVIGATE: '\u2388', ESCAPE: '\u238B', EJECT: '\u23CF',
|
|
|
|
|
SPACE: '\u2423', DIAMOND: '\u25C6',
|
|
|
|
|
STAR: '\u2605', SOUND: '\u266B', TRASH: '\u267A', FLAG: '\u2691',
|
|
|
|
|
ANCHOR: '\u2693', GEAR: '\u2699', ATOM: '\u269B', WARNING: '\u26A0',
|
|
|
|
|
CUT: '\u2702', BACKUP: '\u2707', FLY: '\u2708', CHECK: '\u2713',
|
|
|
|
|
CLOSE: '\u2715', BALLOT: '\u2717', WINDOWS: '\u2756',
|
|
|
|
|
EDIT: '\uF802', CLICK: '\uF803', APPLE: '\uF8FF'
|
|
|
|
|
};
|
|
|
|
|
//@ Ox.TYPES <[str]> list of types, as returned by <code>Ox.type()</code>
|
|
|
|
|
Ox.TYPES = [
|
|
|
|
|
'Arguments', 'Array', 'Boolean', 'Date', 'Element', 'Function', 'Infinity',
|
|
|
|
|
'NaN', 'Null', 'Number', 'Object', 'RegExp', 'String', 'Undefined'
|
|
|
|
|
];
|
|
|
|
|
//@ Ox.VERSION <str> OxJS version number
|
|
|
|
|
Ox.VERSION = '0.1.2';
|
|
|
|
|
//@ Ox.WEEKDAYS <[str]> Names of weekdays
|
|
|
|
|
Ox.WEEKDAYS = [
|
|
|
|
|
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
|
|
|
|
|
];
|
|
|
|
|
//@ Ox.SHORT_WEEKDAYS <[str]> Short names of weekdays
|
|
|
|
|
Ox.SHORT_WEEKDAYS = Ox.WEEKDAYS.map(function(val) {
|
|
|
|
|
return val.substr(0, 3);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
//@ Date -----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
//@ Ox.getDate <f> Get the day of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getDateInWeek <f> Get the date that falls on a given weekday in the same week
|
|
|
|
|
# Usage
|
|
|
|
|
(date, weekday) -> <dat> Date
|
2011-05-06 17:40:26 +00:00
|
|
|
|
(date, weekday, utc) -> <dat> Date
|
2011-05-05 18:02:56 +00:00
|
|
|
|
# Arguments
|
|
|
|
|
date <d> Date
|
|
|
|
|
weekday <n|s> 1-7 (Monday-Sunday) or name, full ("Monday") or short ("Sun")
|
2011-05-06 17:40:26 +00:00
|
|
|
|
utc <b> If true, all dates are UTC
|
2011-05-05 18:02:56 +00:00
|
|
|
|
# Examples
|
|
|
|
|
> Ox.formatDate(Ox.getDateInWeek(new Date("January 1 2000"), "Sunday"), "%A, %B %e, %Y")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"Sunday, January 2, 2000"
|
2011-05-05 18:02:56 +00:00
|
|
|
|
> Ox.formatDate(Ox.getDateInWeek(new Date("Jan 1 2000"), "Fri"), "%A, %B %e, %Y")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"Friday, December 31, 1999"
|
2011-05-05 18:02:56 +00:00
|
|
|
|
> Ox.formatDate(Ox.getDateInWeek(new Date("1/1/2000"), 1), "%A, %B %e, %Y")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"Monday, December 27, 1999"
|
2011-05-05 18:02:56 +00:00
|
|
|
|
@*/
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// fixme: why is this Monday first? shouldn't it then be "getDateInISOWeek"??
|
2011-05-05 18:02:56 +00:00
|
|
|
|
Ox.getDateInWeek = function(date, weekday, utc) {
|
|
|
|
|
/*
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
Ox.print(date, Ox.getDate(date, utc), Ox.formatDate(date, '%u', utc), date)
|
|
|
|
|
var sourceWeekday = Ox.getISODay(date, utc),
|
|
|
|
|
targetWeekday = Ox.isNumber(weekday) ? weekday :
|
|
|
|
|
Ox.map(Ox.WEEKDAYS, function(v, i) {
|
|
|
|
|
return v.substr(0, 3) == weekday.substr(0, 3) ? i + 1 : null;
|
|
|
|
|
})[0];
|
|
|
|
|
Ox.print(date, Ox.getDate(date, utc), sourceWeekday, targetWeekday)
|
|
|
|
|
return Ox.setDate(date, Ox.getDate(date, utc) - sourceWeekday + targetWeekday, utc);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getDay <f> Get the weekday of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
2011-05-06 17:40:26 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getDayOfTheYear <f> Get the day of the year for a given date
|
|
|
|
|
# Usage
|
|
|
|
|
(date) -> <d> Date
|
|
|
|
|
(date, utc) -> <d> Date
|
|
|
|
|
# Arguments
|
|
|
|
|
date <d> Date
|
|
|
|
|
utc <b> If true, all dates are UTC
|
|
|
|
|
# Examples
|
|
|
|
|
> Ox.getDayOfTheYear(new Date("12/31/2000"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
366
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.getDayOfTheYear(new Date("12/31/2002"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
365
|
2011-05-06 17:40:26 +00:00
|
|
|
|
> Ox.getDayOfTheYear(new Date("12/31/2004"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
366
|
2011-05-06 17:40:26 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.getDayOfTheYear = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
var month = Ox.getMonth(date, utc),
|
|
|
|
|
year = Ox.getFullYear(date, utc);
|
|
|
|
|
return Ox.sum(Ox.map(Ox.range(month), function(i) {
|
|
|
|
|
return Ox.getDaysInMonth(year, i + 1);
|
|
|
|
|
})) + Ox.getDate(date, utc);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getDaysInMonth <f> Get the number of days in a given month
|
|
|
|
|
> Ox.getDaysInMonth(2000, 2)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
29
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getDaysInMonth("2002", "Feb")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
28
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getDaysInMonth(new Date('01/01/2004'), "February")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
29
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getDaysInMonth = function(year, month, utc) {
|
|
|
|
|
/*
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
|
|
|
|
year = Ox.makeYear(year);
|
|
|
|
|
month = Ox.isNumber(month) ? month :
|
|
|
|
|
Ox.map(Ox.MONTHS, function(v, i) {
|
|
|
|
|
return v.substr(0, 3) == month.substr(0, 3) ? i + 1 : null;
|
|
|
|
|
})[0];
|
|
|
|
|
return new Date(year, month, 0).getDate();
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*
|
|
|
|
|
Ox.getDaysInYear <f> Get the number of days in a given year
|
|
|
|
|
> Ox.getDaysInYear(1900)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
365
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getDaysInYear('2000')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
366
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getDaysInYear(new Date('01/01/2004'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
366
|
2011-05-07 15:56:29 +00:00
|
|
|
|
*/
|
|
|
|
|
Ox.getDaysInYear = function(year, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return 365 + Ox.isLeapYear(Ox.makeYear(year, utc));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getFirstDayOfTheYear <f> Get the weekday of the first day of a given year
|
|
|
|
|
Returns the decimal weekday of January 1 (0-6, Sunday as first day)
|
|
|
|
|
> Ox.getFirstDayOfTheYear(new Date('01/01/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
6
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getFirstDayOfTheYear = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
date = Ox.setMonth(date, 0, utc);
|
|
|
|
|
date = Ox.setDate(date, 1, utc);
|
|
|
|
|
return Ox.getDay(date, utc)
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getFullYear <f> Get the year of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getHours <f> Get the hours of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.getISODate <f> Get the ISO date string for a given date
|
|
|
|
|
> Ox.getISODate(new Date('01/01/2000'))
|
|
|
|
|
'2000-01-01T00:00:00Z'
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getISODate = function(date, utc) {
|
|
|
|
|
return Ox.formatDate(Ox.makeDate(date), '%FT%TZ', utc);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getISODay <f> Get the ISO weekday of a given date
|
|
|
|
|
Returns the decimal weekday (1-7, Monday as first day)
|
|
|
|
|
> Ox.getISODay(new Date('01/01/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
6
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISODay(new Date('01/02/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
7
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISODay(new Date('01/03/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getISODay = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.getDay(Ox.makeDate(date), utc) || 7;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getISOWeek <f> Get the ISO week of a given date
|
|
|
|
|
See <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>
|
|
|
|
|
> Ox.getISOWeek(new Date('01/01/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
52
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISOWeek(new Date('01/02/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
52
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISOWeek(new Date('01/03/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.getISOWeek = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
// set date to Thursday of the same week
|
|
|
|
|
return Math.floor((Ox.getDayOfTheYear(Ox.setDate(
|
|
|
|
|
date, Ox.getDate(date, utc) - Ox.getISODay(date, utc) + 4, utc
|
|
|
|
|
), utc) - 1) / 7) + 1;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getISOYear <f> Get the ISO year of a given date
|
|
|
|
|
See <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>
|
|
|
|
|
> Ox.getISOYear(new Date("01/01/2000"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1999
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISOYear(new Date("01/02/2000"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1999
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getISOYear(new Date("01/03/2000"))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
2000
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.getISOYear = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
// set date to Thursday of the same week
|
|
|
|
|
return Ox.getFullYear(Ox.setDate(
|
|
|
|
|
date, Ox.getDate(date, utc) - Ox.getISODay(date, utc) + 4, utc
|
|
|
|
|
));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getMilliseconds <f> Get the milliseconds of a date
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getMinutes <f> Get the minutes of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getMonth <f> Get the month of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.getSeconds <f> Get the seconds of a date
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
|
|
|
|
//@ Ox.getTime <f> Alias for <code>+new Date()</code> (deprecated)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getTime = function() {
|
|
|
|
|
// fixme: needed?
|
|
|
|
|
return +new Date();
|
2011-05-07 15:56:29 +00:00
|
|
|
|
};
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getTimezoneOffset <f> Get the local time zone offset in milliseconds
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getTimezoneOffset = function() {
|
|
|
|
|
return new Date().getTimezoneOffset() * 60000;
|
2011-05-07 15:56:29 +00:00
|
|
|
|
};
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getTimezoneOffsetString <f> Get the local time zone offset as a string
|
|
|
|
|
Returns a time zone offset string (from around '-1200' to around '+1200').
|
|
|
|
|
> Ox.getTimezoneOffsetString(new Date('01/01/2000')).length
|
2011-04-27 19:39:56 +00:00
|
|
|
|
5
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getTimezoneOffsetString = function(date) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var offset = (Ox.makeDate(date)).getTimezoneOffset();
|
|
|
|
|
return (offset < 0 ? '+' : '-') +
|
|
|
|
|
Ox.pad(Math.floor(Math.abs(offset) / 60), 2) +
|
|
|
|
|
Ox.pad(Math.abs(offset) % 60, 2);
|
|
|
|
|
};
|
2011-05-07 15:56:29 +00:00
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.getWeek <f> Get the week of a given day
|
|
|
|
|
Returns the week of the year (0-53, Sunday as first day)
|
|
|
|
|
> Ox.getWeek(new Date('01/01/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getWeek(new Date('01/02/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.getWeek(new Date('01/03/2000'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getWeek = function(date, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
return Math.floor((Ox.getDayOfTheYear(date, utc) +
|
|
|
|
|
Ox.getFirstDayOfTheYear(date, utc) - 1) / 7);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isLeapYear <f> Returns true if a given year is a leap year
|
|
|
|
|
> Ox.isLeapYear(1900)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.isLeapYear('2000')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.isLeapYear(new Date('01/01/2004'))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isLeapYear = function(year, utc) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
year = Ox.makeYear(year, utc);
|
|
|
|
|
return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.makeDate <f> Takes a date, number or string, returns a date
|
2011-05-07 17:52:33 +00:00
|
|
|
|
> Ox.formatDate(Ox.makeDate(new Date('01/01/1970')), '%m/%d/%Y')
|
2011-05-07 15:56:29 +00:00
|
|
|
|
'01/01/1970'
|
2011-05-07 17:52:33 +00:00
|
|
|
|
> Ox.formatDate(Ox.makeDate(0), '%m/%d/%Y')
|
2011-05-07 15:56:29 +00:00
|
|
|
|
'01/01/1970'
|
2011-05-07 17:52:33 +00:00
|
|
|
|
> Ox.formatDate(Ox.makeDate('01/01/1970'), '%m/%d/%Y')
|
2011-05-07 15:56:29 +00:00
|
|
|
|
'01/01/1970'
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.makeDate = function(date) {
|
|
|
|
|
return Ox.isDate(date) ? date :
|
|
|
|
|
Ox.isUndefined(date) ? new Date() : new Date(date);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.makeYear <f> Takes a date, number or string, returns a year
|
|
|
|
|
> Ox.makeYear(new Date('01/01/1970'))
|
|
|
|
|
1970
|
|
|
|
|
> Ox.makeYear(1970)
|
|
|
|
|
1970
|
|
|
|
|
> Ox.makeYear('1970')
|
|
|
|
|
1970
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.makeYear = function(date, utc) {
|
|
|
|
|
return Ox.isDate(date) ? Ox.getFullYear(date, utc) : parseInt(date);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setDate <f> Set the day of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setDay <f> Set the weekday of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setFullYear <f> Set the year of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setHours <f> Set the hours of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setMilliseconds <f> Set the milliseconds of a date
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setMinutes <f> Set the minutes of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setMonth <f> Set the month of a date, optionally UTC
|
2011-05-07 17:25:34 +00:00
|
|
|
|
// see Ox.setSeconds for source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.setSeconds <f> Set the seconds of a date
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[
|
|
|
|
|
'FullYear', 'Month', 'Date', 'Day',
|
|
|
|
|
'Hours', 'Minutes', 'Seconds', 'Milliseconds'
|
|
|
|
|
].forEach(function(noun) {
|
|
|
|
|
Ox['get' + noun] = function(date, utc) {
|
|
|
|
|
return Ox.makeDate(date)['get' + (utc ? 'UTC' : '') + noun]()
|
|
|
|
|
}
|
|
|
|
|
Ox['set' + noun] = function(date, num, utc) {
|
|
|
|
|
// new Date(date) makes a clone, so that
|
|
|
|
|
// setSomething() doesn't have side effects
|
|
|
|
|
return new Date(
|
|
|
|
|
Ox.makeDate(date)
|
|
|
|
|
)['set' + (utc ? 'UTC' : '') + noun](num);
|
|
|
|
|
// fixme: maybe we _want_ set to have side effects?
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ DOM ------------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.canvas <function> Generic canvas object
|
|
|
|
|
Returns an object with the properties: <code>canvas</code>,
|
|
|
|
|
<code>context</code>, <code>data</code> and <code>imageData</code>.
|
|
|
|
|
# Usage --------------------------------------------------------------------
|
|
|
|
|
Ox.canvas(width, height) -> <object> canvas
|
|
|
|
|
Ox.canvas(image) -> <object> canvas
|
|
|
|
|
# Arguments ----------------------------------------------------------------
|
|
|
|
|
width <n> Width in px
|
|
|
|
|
height <n> Height in px
|
|
|
|
|
image <e> Image object
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.canvas = function() {
|
|
|
|
|
var c = {}, isImage = arguments.length == 1,
|
|
|
|
|
image = isImage ? arguments[0] : {
|
|
|
|
|
width: arguments[0], height: arguments[1]
|
|
|
|
|
};
|
|
|
|
|
c.context = (c.canvas = Ox.element('<canvas>').attr({
|
|
|
|
|
width: image.width, height: image.height
|
|
|
|
|
})[0]).getContext('2d');
|
|
|
|
|
isImage && c.context.drawImage(image, 0, 0);
|
|
|
|
|
c.data = (c.imageData = c.context.getImageData(
|
|
|
|
|
0, 0, image.width, image.height
|
|
|
|
|
)).data;
|
|
|
|
|
return c;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.documentReady <function> Calls a callback function once the DOM is ready
|
|
|
|
|
(callback) -> <boolean> If true, the document was ready
|
|
|
|
|
callback <function> Callback function
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.documentReady = (function() {
|
|
|
|
|
var callbacks = [];
|
|
|
|
|
document.onreadystatechange = function() {
|
|
|
|
|
if (document.readyState == 'complete') {
|
|
|
|
|
//Ox.print('document has become ready', callbacks);
|
|
|
|
|
callbacks.forEach(function(callback) {
|
|
|
|
|
callback();
|
|
|
|
|
});
|
|
|
|
|
delete callbacks;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
return function(callback) {
|
|
|
|
|
if (document.readyState == 'complete') {
|
|
|
|
|
callback();
|
2011-05-05 18:02:56 +00:00
|
|
|
|
return true;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
} else {
|
|
|
|
|
callbacks.push(callback);
|
2011-05-05 18:02:56 +00:00
|
|
|
|
return false;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
2011-05-06 17:40:26 +00:00
|
|
|
|
Ox.element <f> Generic HTML element, mimics jQuery
|
2011-05-05 18:02:56 +00:00
|
|
|
|
(str) -> <o> Element object
|
|
|
|
|
str <s> Tagname ('<tagname>') or selector ('tagname', '.classname', '#id')
|
2011-05-06 23:30:32 +00:00
|
|
|
|
> Ox.element("<div>").addClass("red").addClass("red")[0].className
|
2011-05-05 18:02:56 +00:00
|
|
|
|
"red"
|
|
|
|
|
> Ox.element("<div>").attr({id: "red"}).attr("id")
|
|
|
|
|
"red"
|
|
|
|
|
> Ox.element("<div>").css("color", "red").css("color")
|
|
|
|
|
"red"
|
|
|
|
|
> Ox.element("<div>").html("red").html()
|
|
|
|
|
"red"
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.element = function(str) {
|
|
|
|
|
return {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
//@ 0 <e> The DOM element itself
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0: str[0] == '<' ? document.createElement(str.substr(1, str.length - 2)) :
|
|
|
|
|
str[0] == '.' ? document.getElementsByClassName(str.substr(1))[0] :
|
|
|
|
|
str[0] == '#' ? document.getElementById(str.substr(1)) :
|
|
|
|
|
document.getElementsByTagName(str)[0],
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
addClass <f> Adds a class name
|
|
|
|
|
(className) -> <o> This element
|
|
|
|
|
className <s> Class name
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
addClass: function(str) {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
this[0].className = this[0].className ? Ox.unique(
|
|
|
|
|
(this[0].className + ' ' + str).split(' ')
|
|
|
|
|
) : str;
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return this;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
2011-05-06 17:40:26 +00:00
|
|
|
|
append <f> Appends another element to this element
|
2011-05-05 18:02:56 +00:00
|
|
|
|
(element) -> <o> This element
|
|
|
|
|
element <o> Another element
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
append: function(element) {
|
|
|
|
|
this[0].appendChild(element[0]);
|
|
|
|
|
return this;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
appendTo <f> appends this element object to another element object
|
|
|
|
|
(element) -> <o> This element
|
|
|
|
|
element <o> Another element
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
appendTo: function(element) {
|
|
|
|
|
element[0].appendChild(this[0]);
|
|
|
|
|
return this;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
attr <f> Gets or sets an attribute
|
|
|
|
|
(key) -> <s> Value
|
|
|
|
|
(key, value) -> <o> This element
|
|
|
|
|
({key, value}) -> <o> This element
|
|
|
|
|
key <str> Attribute name
|
|
|
|
|
value <str> Attribute value
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
attr: function() {
|
|
|
|
|
var ret, that = this;
|
|
|
|
|
if (arguments.length == 1 && Ox.isString(arguments[0])) {
|
|
|
|
|
ret = this[0].getAttribute(arguments[0]);
|
|
|
|
|
} else {
|
2011-04-29 22:07:23 +00:00
|
|
|
|
Ox.forEach(Ox.makeObject(arguments), function(v, k) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
that[0].setAttribute(k, v);
|
|
|
|
|
});
|
|
|
|
|
ret = this;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
css <f> Gets or sets a CSS attribute
|
|
|
|
|
(key) -> <s> Value
|
|
|
|
|
(key, value) -> <o> This element
|
|
|
|
|
({key, value}) -> <o> This element
|
|
|
|
|
key <str> Attribute name
|
|
|
|
|
value <str> Attribute value
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
css: function() {
|
|
|
|
|
var ret, that = this;
|
|
|
|
|
if (arguments.length == 1 && Ox.isString(arguments[0])) {
|
|
|
|
|
ret = this[0].style[arguments[0]];
|
|
|
|
|
} else {
|
2011-04-29 22:07:23 +00:00
|
|
|
|
Ox.forEach(Ox.makeObject(arguments), function(v, k) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
that[0].style[k] = v;
|
|
|
|
|
});
|
|
|
|
|
ret = this;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
html <f> Gets or sets the inner HTML
|
|
|
|
|
() -> <s> The inner HTML
|
|
|
|
|
(html) -> <o> This element
|
|
|
|
|
html <s> The inner HTML
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
html: function(str) {
|
|
|
|
|
var ret;
|
|
|
|
|
if (Ox.isUndefined(str)) {
|
|
|
|
|
ret = this[0].innerHTML;
|
|
|
|
|
} else {
|
|
|
|
|
this[0].innerHTML = str;
|
|
|
|
|
ret = this;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
},
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
mousedown <f> Binds a function to the mousedown event
|
|
|
|
|
(callback) -> <o> This element
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
event <o> The DOM event
|
|
|
|
|
@*/
|
|
|
|
|
mousedown: function(callback) {
|
|
|
|
|
this[0].onmousedown = callback;
|
|
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
/*@
|
|
|
|
|
removeClass <f> Removes a class name
|
|
|
|
|
(className) -> <o> This element
|
|
|
|
|
className <s> Class name
|
|
|
|
|
@*/
|
|
|
|
|
removeClass: function(str) {
|
|
|
|
|
this[0].className = Ox.filter(
|
|
|
|
|
this[0].className.split(' '), function(className) {
|
|
|
|
|
return className != str;
|
|
|
|
|
}
|
|
|
|
|
).join(' ');
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return this;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Encoding -------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
|
|
|
|
|
|
var aliases = {'I': '1', 'L': '1', 'O': '0', 'U': 'V'},
|
|
|
|
|
digits = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
|
|
|
|
|
|
|
|
|
|
function cap(width, height) {
|
|
|
|
|
// returns maximum encoding capacity of an image
|
|
|
|
|
return parseInt(width * height * 3/8) - 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function seek(data, px) {
|
|
|
|
|
// returns this, or the next, opaque pixel
|
|
|
|
|
while (data[px * 4 + 3] < 255) {
|
|
|
|
|
if (++px * 4 == data.length) {
|
|
|
|
|
throwPNGError('de');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return px;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function xor(byte) {
|
|
|
|
|
// returns "1"-bits-in-byte % 2
|
|
|
|
|
var xor = 0;
|
|
|
|
|
Ox.range(8).forEach(function(i) {
|
|
|
|
|
xor ^= byte >> i & 1;
|
|
|
|
|
});
|
|
|
|
|
return xor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function throwPNGError(str) {
|
|
|
|
|
throw new RangeError(
|
|
|
|
|
'PNG codec can\'t ' +
|
|
|
|
|
(str == 'en' ? 'encode data' : 'decode image')
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function throwUTF8Error(byte, pos) {
|
|
|
|
|
throw new RangeError(
|
|
|
|
|
'UTF-8 codec can\'t decode byte 0x' +
|
|
|
|
|
byte.toString(16).toUpperCase() + ' at position ' + pos
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeBase32 <b> Encode a number as base32
|
|
|
|
|
See <a href="http://www.crockford.com/wrmg/base32.html">Base 32</a>.
|
|
|
|
|
> Ox.encodeBase32(15360)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'F00'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.encodeBase32(33819)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'110V'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.encodeBase32 = function(num) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.map(num.toString(32), function(char) {
|
|
|
|
|
return digits[parseInt(char, 32)];
|
|
|
|
|
}).join('');
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeBase32 <f> Decodes a base32-encoded number
|
|
|
|
|
See <a href="http://www.crockford.com/wrmg/base32.html">Base 32</a>.
|
|
|
|
|
> Ox.decodeBase32('foo')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
15360
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.decodeBase32('ILOU')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
33819
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.decodeBase32('?').toString()
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'NaN'
|
2011-05-07 21:07:53 +00:00
|
|
|
|
@*/
|
2011-05-07 15:56:29 +00:00
|
|
|
|
Ox.decodeBase32 = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return parseInt(Ox.map(str.toUpperCase(), function(char) {
|
|
|
|
|
var index = digits.indexOf(aliases[char] || char);
|
|
|
|
|
return (index == -1 ? ' ' : index).toString(32);
|
|
|
|
|
}).join(''), 32);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeBase64 <f> Encode a number as base64
|
|
|
|
|
> Ox.encodeBase64(32394)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'foo'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.encodeBase64 = function(num) {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
return btoa(Ox.encodeBase256(num)).replace(/=/g, '');
|
2011-04-27 19:39:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeBase64 <f> Decodes a base64-encoded number
|
|
|
|
|
> Ox.decodeBase64('foo')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
32394
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.decodeBase64 = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.decodeBase256(atob(str));
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeBase128 <f> Encode a number as base128
|
|
|
|
|
> Ox.encodeBase128(1685487)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'foo'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.encodeBase128 = function(num) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var str = '';
|
|
|
|
|
while (num) {
|
|
|
|
|
str = Ox.char(num & 127) + str;
|
|
|
|
|
num >>= 7;
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeBase128 <f> Decode a base128-encoded number
|
|
|
|
|
> Ox.decodeBase128('foo')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1685487
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.decodeBase128 = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var num = 0, len = str.length;
|
|
|
|
|
Ox.forEach(str, function(char, i) {
|
|
|
|
|
num += char.charCodeAt(0) << (len - i - 1) * 7;
|
|
|
|
|
});
|
|
|
|
|
return num;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeBase256 <f> Encode a number as base256
|
|
|
|
|
> Ox.encodeBase256(6713199)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'foo'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.encodeBase256 = function(num) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var str = '';
|
|
|
|
|
while (num) {
|
|
|
|
|
str = Ox.char(num & 255) + str;
|
|
|
|
|
num >>= 8;
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeBase256 <f> Decode a base256-encoded number
|
|
|
|
|
> Ox.decodeBase256('foo')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
6713199
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.decodeBase256 = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var num = 0, len = str.length;
|
|
|
|
|
Ox.forEach(str, function(char, i) {
|
|
|
|
|
num += char.charCodeAt(0) << (len - i - 1) * 8;
|
|
|
|
|
});
|
|
|
|
|
return num;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.encodeDeflate <f> (undocumented)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.encodeDeflate = function(str) {
|
|
|
|
|
// encodes string, using deflate
|
|
|
|
|
/*
|
|
|
|
|
in fact, the string is written to the rgb channels of a canvas element,
|
|
|
|
|
then the dataURL is decoded from base64, and some head and tail cut off
|
|
|
|
|
*/
|
|
|
|
|
str = Ox.encodeUTF8(str);
|
|
|
|
|
var len = str.length, c = Ox.canvas(Math.ceil((4 + len) / 3), 1), data;
|
|
|
|
|
str = Ox.pad(Ox.encodeBase256(len), 4, Ox.char(0)) + str +
|
|
|
|
|
Ox.repeat('\u00FF', (4 - len % 4) % 4); // simpler? Ox.pad()?
|
|
|
|
|
/* fixme: why does map not work here?
|
|
|
|
|
c.data = $.map(c.data, function(v, i) {
|
|
|
|
|
return i % 4 < 3 ? str.charCodeAt(i - parseInt(i / 4)) : 255;
|
|
|
|
|
});
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < c.data.length; i += 1) {
|
|
|
|
|
c.data[i] = i % 4 < 3 ? str.charCodeAt(i - parseInt(i / 4)) : 255;
|
|
|
|
|
}
|
|
|
|
|
c.context.putImageData(c.imageData, 0, 0);
|
|
|
|
|
Ox.print(c.canvas.toDataURL())
|
|
|
|
|
data = atob(c.canvas.toDataURL().split(',')[1]);
|
|
|
|
|
Ox.print('data', data);
|
|
|
|
|
return data.substr(8, data.length - 20);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.decodeDeflate <f> (undocumented)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.decodeDeflate = function(str) {
|
|
|
|
|
var image = new Image();
|
|
|
|
|
image.src = 'data:image/png;base64,' + btoa('\u0089PNG\r\n\u001A\n' +
|
|
|
|
|
str + Ox.repeat('\u0000', 4) + 'IEND\u00AEB`\u0082');
|
|
|
|
|
Ox.print(image.src);
|
|
|
|
|
while (!image.width) {} // block until image data is available
|
|
|
|
|
str = Ox.map(Ox.canvas(image).data, function(v, i) {
|
|
|
|
|
return i % 4 < 3 ? Ox.char(v) : '';
|
|
|
|
|
}).join('');
|
|
|
|
|
return Ox.decodeUTF8(str.substr(4, Ox.decodeBase256(str.substr(0, 4))));
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeHTML <f> HTML-encodes a string
|
|
|
|
|
> Ox.encodeHTML('\'<"&">\'')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
''<"&">''
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.encodeHTML('äbçdê')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'äbçdê'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.encodeHTML = function(str) {
|
2011-05-07 17:25:34 +00:00
|
|
|
|
return Ox.map(str.toString(), function(v) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var code = v.charCodeAt(0);
|
|
|
|
|
return code < 128 ? (v in Ox.HTML_ENTITIES ? Ox.HTML_ENTITIES[v] : v) :
|
|
|
|
|
'&#x' + Ox.pad(code.toString(16).toUpperCase(), 4) + ';';
|
|
|
|
|
}).join('');
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeHTML <f> Decodes an HTML-encoded string
|
|
|
|
|
> Ox.decodeHTML(''<"&">'')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'\'<"&">\''
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.decodeHTML(''<"&">'')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'\'<"&">\''
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.decodeHTML('äbçdê')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'äbçdê'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.decodeHTML('äbçdê')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'äbçdê'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.decodeHTML = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
// relies on dom, but shorter than using this:
|
|
|
|
|
// http://www.w3.org/TR/html5/named-character-references.html
|
|
|
|
|
return Ox.element('<div>').html(str)[0].childNodes[0].nodeValue;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.encodePNG <f> Encodes a string into an image, returns a new image URL
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.encodePNG = function(img, str) {
|
|
|
|
|
/*
|
|
|
|
|
the message is compressed with deflate (by proxy of canvas),
|
|
|
|
|
then the string (four bytes length) + (length bytes message)
|
|
|
|
|
is encoded bitwise into the r/g/b bytes of all opaque pixels
|
|
|
|
|
by flipping, if necessary, the least significant bit, so that
|
|
|
|
|
(number of "1"-bits of the byte) % 2 is the bit of the string
|
|
|
|
|
wishlist:
|
|
|
|
|
- only use deflate if it actually shortens the message
|
|
|
|
|
- in deflate, strip and later re-insert the chunk types
|
|
|
|
|
- encode a decoy message into the least significant bit
|
|
|
|
|
(and flip the second least significant bit, if at all)
|
|
|
|
|
- write an extra png chunk containing some key
|
|
|
|
|
*/
|
|
|
|
|
//str = Ox.encodeDeflate(str); currently broken
|
|
|
|
|
str = Ox.encodeUTF8(str);
|
|
|
|
|
var c = Ox.canvas(img), len = str.length, px = 0;
|
|
|
|
|
if (len == 0 || len > cap(img.width, img.height)) {
|
|
|
|
|
throwPNGError('en')
|
|
|
|
|
}
|
|
|
|
|
len = Ox.pad(Ox.encodeBase256(len), 4, Ox.char(0));
|
|
|
|
|
Ox.forEach(Ox.map(len + str, function(byte) {
|
|
|
|
|
return Ox.map(Ox.range(8), function(i) {
|
|
|
|
|
return byte.charCodeAt(0) >> 7 - i & 1;
|
|
|
|
|
}).join('');
|
|
|
|
|
}).join(''), function(bit, i) {
|
|
|
|
|
var index = parseInt((px = seek(c.data, px)) * 4 + i % 3),
|
|
|
|
|
byte = c.data[index];
|
|
|
|
|
c.data[index] = bit == xor(byte) ? byte :
|
|
|
|
|
byte & 254 | !(byte & 1);
|
|
|
|
|
px += i % 3 == 2;
|
|
|
|
|
});
|
|
|
|
|
c.context.putImageData(c.imageData, 0, 0);
|
|
|
|
|
return c.canvas.toDataURL();
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.decodePNG <f> Decodes an image, returns a string
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.decodePNG = function(img) {
|
|
|
|
|
var bits = '', data = Ox.canvas(img).data, flag = false, i = 0,
|
|
|
|
|
len = 4, max = cap(img.width, img.height), px = 0, str = '';
|
|
|
|
|
do {
|
|
|
|
|
bits += xor(data[parseInt((px = seek(data, px)) * 4 + i % 3)]);
|
|
|
|
|
px += i % 3 == 2;
|
|
|
|
|
if (++i % 8 == 0) {
|
|
|
|
|
str += Ox.char(parseInt(bits, 2));
|
|
|
|
|
bits = '';
|
|
|
|
|
len--;
|
|
|
|
|
if (len == 0 && !flag) {
|
|
|
|
|
len = Ox.decodeBase256(str);
|
|
|
|
|
if (len <= 0 || len > max) {
|
|
|
|
|
Ox.print(len);
|
|
|
|
|
throwPNGError('de');
|
|
|
|
|
}
|
|
|
|
|
str = '';
|
|
|
|
|
flag = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} while (len);
|
|
|
|
|
try {
|
|
|
|
|
//return Ox.decodeDeflate(str); currently broken
|
|
|
|
|
return Ox.decodeUTF8(str);
|
|
|
|
|
} catch(e) {
|
|
|
|
|
Ox.print(e.toString());
|
|
|
|
|
throwPNGError('de');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.encodeUTF8 <f> Encodes a string as UTF-8
|
|
|
|
|
see http://en.wikipedia.org/wiki/UTF-8
|
|
|
|
|
(string) -> <s> UTF-8 encoded string
|
|
|
|
|
string <s> Any string
|
|
|
|
|
> Ox.encodeUTF8("foo")
|
|
|
|
|
"foo"
|
|
|
|
|
> Ox.encodeUTF8("¥€$")
|
|
|
|
|
"\u00C2\u00A5\u00E2\u0082\u00AC\u0024"
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.encodeUTF8 = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
*/
|
|
|
|
|
return Ox.map(str, function(chr) {
|
|
|
|
|
var code = chr.charCodeAt(0),
|
|
|
|
|
str = '';
|
|
|
|
|
if (code < 128) {
|
|
|
|
|
str = chr;
|
|
|
|
|
} else if (code < 2048) {
|
|
|
|
|
str = String.fromCharCode(code >> 6 | 192) +
|
|
|
|
|
String.fromCharCode(code & 63 | 128);
|
|
|
|
|
} else {
|
|
|
|
|
str = String.fromCharCode(code >> 12 | 224) +
|
|
|
|
|
String.fromCharCode(code >> 6 & 63 | 128) +
|
|
|
|
|
String.fromCharCode(code & 63 | 128);
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
}).join('');
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.decodeUTF8 <f> Decodes an UTF-8-encoded string
|
|
|
|
|
see http://en.wikipedia.org/wiki/UTF-8
|
|
|
|
|
(utf8) -> <s> string
|
|
|
|
|
utf8 <s> Any UTF-8-encoded string
|
|
|
|
|
> Ox.decodeUTF8('foo')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'foo'
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.decodeUTF8('\u00C2\u00A5\u00E2\u0082\u00AC\u0024')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'¥€$'
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.decodeUTF8 = function(str) {
|
|
|
|
|
/*
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
|
|
|
|
var bytes = Ox.map(str, function(v) {
|
|
|
|
|
return v.charCodeAt(0);
|
|
|
|
|
}),
|
|
|
|
|
i = 0,
|
|
|
|
|
len = str.length,
|
|
|
|
|
str = '';
|
|
|
|
|
while (i < len) {
|
|
|
|
|
if (bytes[i] <= 128) {
|
|
|
|
|
str += String.fromCharCode(bytes[i]);
|
|
|
|
|
i++;
|
|
|
|
|
} else if (
|
|
|
|
|
bytes[i] >= 192 && bytes[i] < 240 &&
|
|
|
|
|
i < len - (bytes[i] < 224 ? 1 : 2)
|
|
|
|
|
) {
|
|
|
|
|
if (bytes[i + 1] >= 128 && bytes[i + 1] < 192) {
|
|
|
|
|
if (bytes[i] < 224) {
|
|
|
|
|
str += String.fromCharCode((bytes[i] & 31) << 6 |
|
|
|
|
|
bytes[i + 1] & 63);
|
|
|
|
|
i += 2;
|
|
|
|
|
} else if (bytes[i + 2] >= 128 && bytes[i + 2] < 192) {
|
|
|
|
|
str += String.fromCharCode((bytes[i] & 15) << 12 |
|
|
|
|
|
(bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63);
|
|
|
|
|
i += 3;
|
|
|
|
|
} else {
|
|
|
|
|
throwUTF8Error(bytes[i + 2], i + 2);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
throwUTF8Error(bytes[i + 1], i + 1);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
throwUTF8Error(bytes[i], i);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
})();
|
|
|
|
|
|
2011-05-07 17:25:34 +00:00
|
|
|
|
//@ Format ---------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatArea <f> Formats a number of meters as square kilometers
|
|
|
|
|
> Ox.formatArea(1000000)
|
|
|
|
|
'1 km\u00B2'
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.formatArea = function(num, dec) {
|
|
|
|
|
return Ox.formatNumber(Ox.round(num / 1000000, dec)) + ' km\u00B2';
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatColor <f> (not implemented)
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.formatColor = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatCurrency <f> Formats a number with a currency symbol
|
|
|
|
|
> Ox.formatCurrency(1000, '$', 2)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'$1,000.00'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.formatCurrency = function(num, str, dec) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return str + Ox.formatNumber(num, dec);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatDate <f> Formats a date according to a format string
|
|
|
|
|
See
|
|
|
|
|
<a href="http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/strftime.3.html">strftime</a>
|
|
|
|
|
and <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>.
|
2011-05-07 17:25:34 +00:00
|
|
|
|
<script>
|
|
|
|
|
Ox.test.date = new Date('2005-01-02 00:03:04');
|
|
|
|
|
</script>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatDate(Ox.test.date, '%A') // Full weekday
|
|
|
|
|
'Sunday'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%a') // Abbreviated weekday
|
|
|
|
|
'Sun'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%B') // Full month
|
|
|
|
|
'January'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%b') // Abbreviated month
|
|
|
|
|
'Jan'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%C') // Century
|
|
|
|
|
'20'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%c') // US time and date
|
|
|
|
|
'01/02/05 12:03:04 AM'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%D') // US date
|
|
|
|
|
'01/02/05'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%d') // Zero-padded day of the month
|
|
|
|
|
'02'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%e') // Space-padded day of the month
|
|
|
|
|
' 2'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%F') // Date
|
|
|
|
|
'2005-01-02'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%G') // Full ISO-8601 year
|
|
|
|
|
'2004'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%g') // Abbreviated ISO-8601 year
|
|
|
|
|
'04'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%H') // Zero-padded hour (24-hour clock)
|
|
|
|
|
'00'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%h') // Abbreviated month
|
|
|
|
|
'Jan'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%I') // Zero-padded hour (12-hour clock)
|
|
|
|
|
'12'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%j') // Zero-padded day of the year
|
|
|
|
|
'002'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%k') // Space-padded hour (24-hour clock)
|
|
|
|
|
' 0'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%l') // Space-padded hour (12-hour clock)
|
|
|
|
|
'12'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%M') // Zero-padded minute
|
|
|
|
|
'03'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%m') // Zero-padded month
|
|
|
|
|
'01'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%n') // Newline
|
|
|
|
|
'\n'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%p') // AM or PM
|
|
|
|
|
'AM'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%Q') // Quarter of the year
|
|
|
|
|
'1'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%R') // Zero-padded hour and minute
|
|
|
|
|
'00:03'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%r') // US time
|
|
|
|
|
'12:03:04 AM'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%S') // Zero-padded second
|
|
|
|
|
'04'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%s', true) // Number of seconds since the Epoch
|
|
|
|
|
'1104620584'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%T') // Time
|
|
|
|
|
'00:03:04'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%t') // Tab
|
|
|
|
|
'\t'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%U') // Zero-padded week of the year (00-53, Sunday as first day)
|
|
|
|
|
'01'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%u') // Decimal weekday (1-7, Monday as first day)
|
|
|
|
|
'7'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%V') // Zero-padded ISO-8601 week of the year
|
|
|
|
|
'53'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%v') // Formatted date
|
|
|
|
|
' 2-Jan-2005'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%W') // Zero-padded week of the year (00-53, Monday as first day)
|
|
|
|
|
'00'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%w') // Decimal weekday (0-6, Sunday as first day)
|
|
|
|
|
'0'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%X') // US time
|
|
|
|
|
'12:03:04 AM'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%x') // US date
|
|
|
|
|
'01/02/05'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%Y') // Full year
|
|
|
|
|
'2005'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%y') // Abbreviated year
|
|
|
|
|
'05'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%Z', true) // Time zone name
|
|
|
|
|
'UTC'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%z', true) // Time zone offset
|
|
|
|
|
'+0000'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%+', true) // Formatted date and time
|
|
|
|
|
'Sun Jan 2 00:03:04 CET 2005'
|
|
|
|
|
> Ox.formatDate(Ox.test.date, '%%')
|
|
|
|
|
'%'
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.formatDate = function(date, str, utc) {
|
|
|
|
|
// fixme: date and utc are optional, date can be date, number or string
|
|
|
|
|
date = Ox.makeDate(date);
|
|
|
|
|
var format = [
|
|
|
|
|
['%', function() {return '%{%}';}],
|
|
|
|
|
['c', function() {return '%x %X';}],
|
|
|
|
|
['X', function() {return '%r';}],
|
|
|
|
|
['x', function() {return '%D';}],
|
|
|
|
|
['D', function() {return '%m/%d/%y';}],
|
|
|
|
|
['F', function() {return '%Y-%m-%d';}],
|
|
|
|
|
['h', function() {return '%b';}],
|
|
|
|
|
['R', function() {return '%H:%M';}],
|
|
|
|
|
['r', function() {return '%I:%M:%S %p';}],
|
|
|
|
|
['T', function() {return '%H:%M:%S';}],
|
|
|
|
|
['v', function() {return '%e-%b-%Y';}],
|
|
|
|
|
['\\+', function() {return '%a %b %e %H:%M:%S %Z %Y';}],
|
|
|
|
|
['A', function(d) {return Ox.WEEKDAYS[(Ox.getDay(d, utc) + 6) % 7];}],
|
|
|
|
|
['a', function(d) {return Ox.SHORT_WEEKDAYS[(Ox.getDay(d, utc) + 6) % 7];}],
|
|
|
|
|
['B', function(d) {return Ox.MONTHS[Ox.getMonth(d, utc)];}],
|
|
|
|
|
['b', function(d) {return Ox.SHORT_MONTHS[Ox.getMonth(d, utc)];}],
|
|
|
|
|
['C', function(d) {return Math.floor(Ox.getFullYear(d, utc) / 100).toString();}],
|
|
|
|
|
['d', function(d) {return Ox.pad(Ox.getDate(d, utc), 2);}],
|
|
|
|
|
['e', function(d) {return Ox.pad(Ox.getDate(d, utc), 2, ' ');}],
|
|
|
|
|
['G', function(d) {return Ox.getISOYear(d, utc);}],
|
|
|
|
|
['g', function(d) {return Ox.getISOYear(d, utc).toString().substr(-2);}],
|
|
|
|
|
['H', function(d) {return Ox.pad(Ox.getHours(d, utc), 2);}],
|
|
|
|
|
['I', function(d) {return Ox.pad((Ox.getHours(d, utc) + 11) % 12 + 1, 2);}],
|
|
|
|
|
['j', function(d) {return Ox.pad(Ox.getDayOfTheYear(d, utc), 3);}],
|
|
|
|
|
['k', function(d) {return Ox.pad(Ox.getHours(d, utc), 2, ' ');}],
|
|
|
|
|
['l', function(d) {return Ox.pad(((Ox.getHours(d, utc) + 11) % 12 + 1), 2, ' ');}],
|
|
|
|
|
['M', function(d) {return Ox.pad(Ox.getMinutes(d, utc), 2);}],
|
|
|
|
|
['m', function(d) {return Ox.pad((Ox.getMonth(d, utc) + 1), 2);}],
|
|
|
|
|
['p', function(d) {return Ox.AMPM[Math.floor(Ox.getHours(d, utc) / 12)];}],
|
|
|
|
|
['Q', function(d) {return Math.floor(Ox.getMonth(d, utc) / 4) + 1;}],
|
|
|
|
|
['S', function(d) {return Ox.pad(Ox.getSeconds(d, utc), 2);}],
|
|
|
|
|
['s', function(d) {return Math.floor(d.getTime() / 1000);}],
|
|
|
|
|
['U', function(d) {return Ox.pad(Ox.getWeek(d, utc), 2);}],
|
|
|
|
|
['u', function(d) {return Ox.getISODay(d, utc);}],
|
|
|
|
|
['V', function(d) {return Ox.pad(Ox.getISOWeek(d, utc), 2);}],
|
|
|
|
|
['W', function(d) {return Ox.pad(Math.floor((Ox.getDayOfTheYear(d, utc) +
|
|
|
|
|
(Ox.getFirstDayOfTheYear(d, utc) || 7) - 2) / 7), 2);}],
|
|
|
|
|
['w', function(d) {return Ox.getDay(d, utc);}],
|
|
|
|
|
['Y', function(d) {return Ox.getFullYear(d, utc);}],
|
|
|
|
|
['y', function(d) {return Ox.getFullYear(d, utc).toString().substr(-2);}],
|
|
|
|
|
['Z', function(d) {return d.toString().split('(')[1].replace(')', '');}],
|
|
|
|
|
['z', function(d) {return Ox.getTimezoneOffsetString(d);}],
|
|
|
|
|
['n', function() {return '\n';}],
|
|
|
|
|
['t', function() {return '\t';}],
|
|
|
|
|
['\\{%\\}', function() {return '%';}]
|
|
|
|
|
];
|
|
|
|
|
format.forEach(function(v) {
|
|
|
|
|
var regexp = new RegExp('%' + v[0], 'g');
|
|
|
|
|
if (regexp.test(str)) {
|
|
|
|
|
str = str.replace(regexp, v[1](date));
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return str;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatDuration <f> Formats a duration as a string
|
|
|
|
|
> Ox.formatDuration(123456.789, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"1:10:17:36.789"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatDuration(12345.6789)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"03:25:46"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatDuration(12345.6789, true)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"0:03:25:46"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatDuration(3599.999, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"00:59:59.999"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatDuration(3599.999)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"01:00:00"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.formatDuration = function(sec, dec, format) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var format = arguments.length == 3 ? format : (Ox.isString(dec) ? dec : "short"),
|
|
|
|
|
dec = (arguments.length == 3 || Ox.isNumber(dec)) ? dec : 0,
|
|
|
|
|
sec = dec ? sec : Math.round(sec),
|
|
|
|
|
val = [
|
|
|
|
|
Math.floor(sec / 31536000),
|
|
|
|
|
Math.floor(sec % 31536000 / 86400),
|
|
|
|
|
Math.floor(sec % 86400 / 3600),
|
|
|
|
|
Math.floor(sec % 3600 / 60),
|
|
|
|
|
format == "short" ? Ox.formatNumber(sec % 60, dec) : sec % 60
|
|
|
|
|
],
|
|
|
|
|
str = {
|
|
|
|
|
medium: ["y", "d", "h", "m", "s"],
|
|
|
|
|
long: ["year", "day", "hour", "minute", "second"]
|
|
|
|
|
},
|
|
|
|
|
pad = [0, 3, 2, 2, dec ? dec + 3 : 2];
|
|
|
|
|
while (!val[0] && val.length > (format == "short" ? 3 : 1)) {
|
|
|
|
|
val.shift();
|
|
|
|
|
str.medium.shift();
|
|
|
|
|
str.long.shift();
|
|
|
|
|
pad.shift();
|
|
|
|
|
}
|
|
|
|
|
while (format != "short" && !val[val.length - 1] && val.length > 1) {
|
|
|
|
|
val.pop();
|
|
|
|
|
str.medium.pop();
|
|
|
|
|
str.long.pop();
|
|
|
|
|
}
|
|
|
|
|
return Ox.map(val, function(v, i) {
|
|
|
|
|
return format == "short" ? Ox.pad(v, pad[i]) :
|
|
|
|
|
v + (format == "long" ? " " : "") + str[format][i] +
|
|
|
|
|
(format == "long" && v != 1 ? "s" : "");
|
|
|
|
|
}).join(format == "short" ? ":" : " ");
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatNumber <f> Formats a number with thousands separators
|
|
|
|
|
> Ox.formatNumber(123456789, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"123,456,789.000"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatNumber(-2000000 / 3, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"-666,666.667"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatNumber(666666.666)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"666,667"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.formatNumber = function(num, dec) {
|
|
|
|
|
// fixme: specify decimal and thousands separators
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var str = Math.abs(num).toFixed(dec || 0),
|
|
|
|
|
spl = str.split('.'),
|
|
|
|
|
arr = [];
|
|
|
|
|
while (spl[0]) {
|
|
|
|
|
arr.unshift(spl[0].substr(-3));
|
|
|
|
|
spl[0] = spl[0].substr(0, spl[0].length - 3);
|
|
|
|
|
}
|
|
|
|
|
spl[0] = arr.join(',');
|
|
|
|
|
return (num < 0 ? '-' : '') + spl.join('.');
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatOrdinal <f> Formats a number as an ordinal
|
|
|
|
|
> Ox.formatOrdinal(1)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"1st"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(2)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"2nd"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"3rd"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(4)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"4th"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(11)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"11th"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(12)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"12th"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatOrdinal(13)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"13th"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.formatOrdinal = function(num) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var str = num.toString(),
|
|
|
|
|
end = str[str.length - 1],
|
|
|
|
|
ten = str.length > 1 && str[str.length - 2] == '1';
|
|
|
|
|
if (end == '1' && !ten) {
|
|
|
|
|
str += 'st';
|
|
|
|
|
} else if (end == '2' && !ten) {
|
|
|
|
|
str += 'nd';
|
|
|
|
|
} else if (end == '3' && !ten) {
|
|
|
|
|
str += 'rd';
|
|
|
|
|
} else {
|
|
|
|
|
str += 'th';
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatPercent <f> Formats the relation of two numbers as a percentage
|
|
|
|
|
> Ox.formatPercent(1, 1000, 2)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"0.10%"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.formatPercent = function(num, total, dec) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Ox.formatNumber(num / total * 100, dec) + '%'
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatResolution <f> Formats two values as a resolution
|
|
|
|
|
> Ox.formatResolution([1920, 1080], 'px')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"1920 x 1080 px"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
// fixme: should be formatDimensions
|
|
|
|
|
Ox.formatResolution = function(arr, str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return arr[0] + ' x ' + arr[1] + (str ? ' ' + str : '');
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatString <f> Basic string formatting
|
|
|
|
|
> Ox.formatString('{0}{1}', ['foo', 'bar'])
|
2011-05-07 17:25:34 +00:00
|
|
|
|
'foobar'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatString('{a}{b}', {a: 'foo', b: 'bar'})
|
|
|
|
|
'foobar'
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.formatString = function (str, obj) {
|
|
|
|
|
return str.replace(/\{([^}]+)\}/g, function(str, match) {
|
|
|
|
|
return obj[match];
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatValue <f> Formats a numerical value
|
|
|
|
|
> Ox.formatValue(0, "B")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"0 KB"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatValue(123456789, "B")
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"123.5 MB"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.formatValue(1234567890, "B", true)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
"1.15 GiB"
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
// fixme: is this the best name?
|
|
|
|
|
Ox.formatValue = function(num, str, bin) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var base = bin ? 1024 : 1000,
|
|
|
|
|
len = Ox.PREFIXES.length,
|
|
|
|
|
val;
|
|
|
|
|
Ox.forEach(Ox.PREFIXES, function(chr, i) {
|
|
|
|
|
if (num < Math.pow(base, i + 2) || i == len - 1) {
|
|
|
|
|
val = Ox.formatNumber(num / Math.pow(base, i + 1), i) +
|
|
|
|
|
' ' + chr + (bin ? 'i' : '') + str;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return val;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.formatUnit <f> Formats a number with a unit
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.formatUnit = function(num, str) {
|
|
|
|
|
return num + ' ' + str;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 17:25:34 +00:00
|
|
|
|
//@ Geo ------------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// fixme: make all this work with different types of "points"
|
|
|
|
|
// i.e. {lat, lng}, [lat, lng]
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
function rad(point) {
|
|
|
|
|
return {
|
|
|
|
|
lat: Ox.rad(point.lat),
|
|
|
|
|
lng: Ox.rad(point.lng)
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.crossesDateline <f> Returns true if a given rectangle crosses the dateline
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.crossesDateline = function(point0, point1) {
|
|
|
|
|
return point0.lng > point1.lng;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getArea <f> Returns the area in square meters of a given rectancle
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getArea = function(point0, point1) {
|
|
|
|
|
/*
|
|
|
|
|
area of a ring between two latitudes:
|
|
|
|
|
2 * PI * r^2 * abs(sin(lat0) - sin(lat1))
|
|
|
|
|
see http://mathforum.org/library/drmath/view/63767.html
|
|
|
|
|
*/
|
|
|
|
|
/*
|
|
|
|
|
2 * Math.PI *
|
|
|
|
|
Math.pow(Ox.EARTH_RADIUS, 2) *
|
|
|
|
|
Math.abs(Math.sin(Ox.rad(0)) - Math.sin(Ox.rad(1))) *
|
|
|
|
|
Math.abs(Ox.rad(0) - Ox.rad(1)) /
|
|
|
|
|
(2 * Math.PI)
|
|
|
|
|
*/
|
|
|
|
|
if (Ox.crossesDateline(point0, point1)) {
|
|
|
|
|
point1.lng += 360;
|
|
|
|
|
}
|
|
|
|
|
var point0 = rad(point0),
|
|
|
|
|
point1 = rad(point1);
|
|
|
|
|
return Math.pow(Ox.EARTH_RADIUS, 2) *
|
|
|
|
|
Math.abs(Math.sin(point0.lat) - Math.sin(point1.lat)) *
|
|
|
|
|
Math.abs(point0.lng - point1.lng);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getBearing <f> Returns the bearing from one point to another
|
|
|
|
|
> Ox.getBearing({lat: -45, lng: 0}, {lat: 45, lng: 0})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.getBearing = function(point0, point1) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var point0 = rad(point0),
|
|
|
|
|
point1 = rad(point1),
|
|
|
|
|
x = Math.cos(point0.lat) * Math.sin(point1.lat) -
|
|
|
|
|
Math.sin(point0.lat) * Math.cos(point1.lat) *
|
|
|
|
|
Math.cos(point1.lng - point0.lng),
|
|
|
|
|
y = Math.sin(point1.lng - point0.lng) *
|
|
|
|
|
Math.cos(point1.lat);
|
|
|
|
|
return (Ox.deg(Math.atan2(y, x)) + 360) % 360;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getCenter <f> Returns the center of a recangle on a spehre
|
|
|
|
|
> Ox.getCenter({lat: -45, lng: -90}, {lat: 45, lng: 90})
|
|
|
|
|
{lat: 0, lng: 0}
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getCenter = function(point0, point1) {
|
|
|
|
|
var point0 = rad(point0),
|
|
|
|
|
point1 = rad(point1),
|
|
|
|
|
x = Math.cos(point1.lat) *
|
|
|
|
|
Math.cos(point1.lng - point0.lng),
|
|
|
|
|
y = Math.cos(point1.lat) *
|
|
|
|
|
Math.sin(point1.lng - point0.lng),
|
|
|
|
|
d = Math.sqrt(
|
|
|
|
|
Math.pow(Math.cos(point0.lat) + x, 2) + Math.pow(y, 2)
|
|
|
|
|
),
|
|
|
|
|
lat = Ox.deg(
|
|
|
|
|
Math.atan2(Math.sin(point0.lat) + Math.sin(point1.lat), d)
|
|
|
|
|
),
|
|
|
|
|
lng = Ox.deg(
|
|
|
|
|
point0.lng + Math.atan2(y, Math.cos(point0.lat) + x)
|
|
|
|
|
);
|
|
|
|
|
return {lat: lat, lng: lng};
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getDegreesPerMeter <f> Returns degrees per meter at a given latitude
|
|
|
|
|
> 360 / Ox.getDegreesPerMeter(0)
|
|
|
|
|
Ox.EARTH_CIRCUMFERENCE
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getDegreesPerMeter = function(lat) {
|
|
|
|
|
return 360 / Ox.EARTH_CIRCUMFERENCE / Math.cos(lat * Math.PI / 180);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getDistance <f> Returns the distance in meters between two points
|
|
|
|
|
> Ox.getDistance({lat: -45, lng: -90}, {lat: 45, lng: 90}) * 2
|
|
|
|
|
Ox.EARTH_CIRCUMFERENCE
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getDistance = function(point0, point1) {
|
|
|
|
|
var point0 = rad(point0),
|
|
|
|
|
point1 = rad(point1);
|
|
|
|
|
return Math.acos(
|
|
|
|
|
Math.sin(point0.lat) * Math.sin(point1.lat) +
|
|
|
|
|
Math.cos(point0.lat) * Math.cos(point1.lat) *
|
|
|
|
|
Math.cos(point1.lng - point0.lng)
|
|
|
|
|
) * Ox.EARTH_RADIUS;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getLatLngByXY <f> Returns lat/lng for a given x/y on a 1x1 mercator projection
|
|
|
|
|
> Ox.values(Ox.getLatLngByXY({x: 0.5, y: 0.5}))
|
|
|
|
|
{lat: 0, lng: 0}
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getLatLngByXY = function(xy) {
|
|
|
|
|
function getVal(val) {
|
|
|
|
|
return (val - 0.5) * 2 * Math.PI;
|
|
|
|
|
}
|
|
|
|
|
return {
|
|
|
|
|
lat: -Ox.deg(Math.atan(Ox.sinh(getVal(xy.y)))),
|
|
|
|
|
lng: Ox.deg(getVal(xy.x))
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getMetersPerDegree <f> Returns meters per degree at a given latitude
|
|
|
|
|
> Ox.getMetersPerDegree(0) * 360
|
|
|
|
|
Ox.EARTH_CIRCUMFERENCE
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getMetersPerDegree = function(lat) {
|
|
|
|
|
return Math.cos(lat * Math.PI / 180) * Ox.EARTH_CIRCUMFERENCE / 360;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.getXYByLatLng <f> Returns x/y on a 1x1 mercator projection for a given lat/lng
|
|
|
|
|
> Ox.getXYByLatLng({lat: 0, lng: 0})
|
|
|
|
|
{x: 0.5, y: 0.5}
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.getXYByLatLng = function(latlng) {
|
|
|
|
|
function getVal(val) {
|
|
|
|
|
return (val / (2 * Math.PI) + 0.5)
|
|
|
|
|
}
|
|
|
|
|
return {
|
|
|
|
|
x: getVal(Ox.rad(latlng.lng)),
|
|
|
|
|
y: getVal(Ox.asinh(Math.tan(Ox.rad(-latlng.lat))))
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.Line <f> (undocumented)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.Line = function(point0, point1) {
|
|
|
|
|
|
|
|
|
|
var self = {
|
|
|
|
|
points: [point0, point1]
|
|
|
|
|
},
|
|
|
|
|
that = this;
|
|
|
|
|
|
|
|
|
|
function rad() {
|
|
|
|
|
return self.points.map(function(point) {
|
|
|
|
|
return {
|
|
|
|
|
lat: Ox.rad(point.lat()),
|
|
|
|
|
lng: Ox.rad(point.lng())
|
|
|
|
|
};
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
that.getArea = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.getBearing = function() {
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.getDistance = function() {
|
|
|
|
|
var points = rad();
|
|
|
|
|
return Math.acos(
|
|
|
|
|
Math.sin(point[0].lat) * Math.sin(point[1].lat) +
|
|
|
|
|
Math.cos(point[0].lat) * Math.cos(point[1].lat) *
|
|
|
|
|
Math.cos(point[1].lng - point[0].lng)
|
|
|
|
|
) * Ox.EARTH_RADIUS;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.getMidpoint = function() {
|
|
|
|
|
var points = rad(),
|
|
|
|
|
x = Math.cos(point[1].lat) *
|
|
|
|
|
Math.cos(point[1].lng - point[0].lng),
|
|
|
|
|
y = Math.cos(point[1].lat) *
|
|
|
|
|
Math.sin(point[1].lng - point[0].lng),
|
|
|
|
|
d = Math.sqrt(
|
|
|
|
|
Math.pow(Math.cos(point[0].lat) + x, 2) + Math.pow(y, 2)
|
|
|
|
|
),
|
|
|
|
|
lat = Ox.deg(
|
|
|
|
|
Math.atan2(Math.sin(points[0].lat) + Math.sin(points[1].lat), d)
|
|
|
|
|
),
|
|
|
|
|
lng = Ox.deg(
|
|
|
|
|
points[0].lng + Math.atan2(y, math.cos(points[0].lat) + x)
|
|
|
|
|
);
|
|
|
|
|
return new Point(lat, lng);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.points = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return that;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.Point <f> (undocumented)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.Point = function(lat, lng) {
|
|
|
|
|
|
|
|
|
|
var self = {lat: lat, lng: lng},
|
|
|
|
|
that = this;
|
|
|
|
|
|
|
|
|
|
that.lat = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.latlng = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.lng = function() {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.getMetersPerDegree = function() {
|
|
|
|
|
return Math.cos(self.lat * Math.PI / 180) *
|
|
|
|
|
Ox.EARTH_CIRCUMFERENCE / 360;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
that.getXY = function() {
|
|
|
|
|
return [
|
|
|
|
|
getXY(Ox.rad(self.lng)),
|
|
|
|
|
getXY(Ox.asinh(Math.tan(Ox.rad(-self.lat))))
|
|
|
|
|
];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return that;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Ox.Rectangle <f> (undocumented)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.Rectangle = function(point0, point1) {
|
|
|
|
|
|
|
|
|
|
var self = {
|
|
|
|
|
points: [
|
|
|
|
|
new Point(
|
|
|
|
|
Math.min(point0.lat(), point1.lat()),
|
|
|
|
|
point0.lng()
|
|
|
|
|
),
|
|
|
|
|
new Point(
|
|
|
|
|
Math.max(point0.lat(), point1.lat()),
|
|
|
|
|
point1.lng()
|
|
|
|
|
)
|
|
|
|
|
]
|
|
|
|
|
},
|
|
|
|
|
that = this;
|
|
|
|
|
|
|
|
|
|
that.contains = function(rectangle) {
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
that.crossesDateline = function() {
|
|
|
|
|
return self.points[0].lng > self.points[1].lng;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
that.getCenter = function() {
|
|
|
|
|
return new Ox.Line(self.points[0], self.points[1]).getMidpoint();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
that.intersects = function(rectangle) {
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return that;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ HTML -----------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.parseEmailAddresses <f> Takes HTML and turns e-mail addresses into links
|
|
|
|
|
@*/
|
|
|
|
|
// fixme: no tests
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.parseEmailAddresses = function(html) {
|
|
|
|
|
return html.replace(
|
|
|
|
|
/\b([0-9A-Z\.\+\-_]+@(?:[0-9A-Z\-]+\.)+[A-Z]{2,6})\b/gi,
|
|
|
|
|
'<a href="mailto:$1" title="mailto:$1">$1</a>'
|
|
|
|
|
);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.parseHTML <f> Takes HTML from an untrusted source and returns something sane
|
|
|
|
|
> Ox.parseHTML('http://foo.com, bar')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<a href="http://foo.com" title="http://foo.com">foo.com</a>, bar'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('(see: www.foo.com)')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'(see: <a href="http://www.foo.com" title="http://www.foo.com">www.foo.com</a>)'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('foo@bar.com')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<a href="mailto:foo@bar.com" title="mailto:foo@bar.com">foo@bar.com</a>'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('<a href="http://foo.com" onmouseover="alert()">foo</a>')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<a href="http://foo.com" title="http://foo.com">foo</a>'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('<a href="javascript:alert()">foo</a>')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<a href="javascript:alert()">foo</a>'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('[http://foo.com foo]')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<a href="http://foo.com" title="http://foo.com">foo</a>'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('<rtl>foo</rtl>')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
'<div style="direction: rtl">foo</div>'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.parseHTML('<script>alert()</script>')
|
|
|
|
|
'<script>alert()</script>'
|
|
|
|
|
@*/
|
|
|
|
|
Ox.parseHTML = (function() {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var defaultTags = [
|
2011-05-05 18:02:56 +00:00
|
|
|
|
'a', 'b', 'blockquote', 'cite', 'code',
|
|
|
|
|
'del', 'em', 'i', 'img', 'ins',
|
|
|
|
|
'li', 'ol', 'q', 'rtl', 's',
|
|
|
|
|
'strong', 'sub', 'sup', 'ul', '[]'
|
2011-04-27 19:39:56 +00:00
|
|
|
|
],
|
|
|
|
|
parse = {
|
|
|
|
|
a: {
|
|
|
|
|
'<a [^<>]*?href="(https?:\/\/.+?)".*?>': '<a href="{1}" title="{1}">',
|
|
|
|
|
'<\/a>': '</a>'
|
|
|
|
|
},
|
|
|
|
|
img: {
|
|
|
|
|
'<img [^<>]*?src="(https?:\/\/.+?)".*?>': '<img src="{1}">'
|
|
|
|
|
},
|
|
|
|
|
rtl: {
|
|
|
|
|
'<rtl>': '<div style="direction: rtl">',
|
|
|
|
|
'<\/rtl>': '</div>'
|
|
|
|
|
},
|
|
|
|
|
'*': function(tag) {
|
|
|
|
|
var ret = {};
|
|
|
|
|
ret['<(/?' + tag + ')>'] = '<{1}>';
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
tab = '\t';
|
|
|
|
|
|
|
|
|
|
return function(html, tags, wikilinks) {
|
|
|
|
|
var matches = [],
|
|
|
|
|
tags = tags || defaultTags;
|
2011-05-06 17:40:26 +00:00
|
|
|
|
// html = Ox.clean(html); fixme: can this be a parameter?
|
2011-04-27 19:39:56 +00:00
|
|
|
|
if (tags.indexOf('[]') > -1) {
|
|
|
|
|
html = html.replace(/\[(https?:\/\/.+?) (.+?)\]/gi, '<a href="$1">$2</a>');
|
|
|
|
|
tags = tags.filter(function(tag) {
|
|
|
|
|
return tag != '[]';
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
tags.forEach(function(tag) {
|
|
|
|
|
var p = parse[tag] || parse['*'](tag);
|
|
|
|
|
Ox.forEach(p, function(replace, regexp) {
|
|
|
|
|
html = html.replace(new RegExp(regexp, 'gi'), function() {
|
|
|
|
|
matches.push(Ox.formatString(replace, arguments));
|
|
|
|
|
return tab + (matches.length - 1) + tab;
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
html = Ox.encodeHTML(html);
|
|
|
|
|
html = Ox.parseURLs(html);
|
|
|
|
|
html = Ox.parseEmailAddresses(html);
|
|
|
|
|
matches.forEach(function(match, i) {
|
|
|
|
|
html = html.replace(new RegExp(tab + i + tab, 'gi'), match);
|
|
|
|
|
});
|
|
|
|
|
html = html.replace(/\n/g, '<br/>\n')
|
|
|
|
|
// close extra opening (and remove extra closing) tags
|
|
|
|
|
// return $('<div>').html(html).html();
|
|
|
|
|
// fixme: this converts '"' to '"'
|
|
|
|
|
return Ox.element('<div>').html(html).html();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.parseURL <f> Takes a URL, returns its components
|
|
|
|
|
(url) -> <o> URL components
|
|
|
|
|
url <s> URL
|
2011-05-07 17:25:34 +00:00
|
|
|
|
<script>
|
|
|
|
|
Ox.test.object = Ox.parseURL('http://www.foo.com:8080/bar/index.html?a=0&b=1#c');
|
|
|
|
|
</script>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.test.object.hash
|
|
|
|
|
'#c'
|
|
|
|
|
> Ox.test.object.host
|
|
|
|
|
'www.foo.com:8080'
|
|
|
|
|
> Ox.test.object.hostname
|
|
|
|
|
'www.foo.com'
|
|
|
|
|
> Ox.test.object.origin
|
|
|
|
|
'http://www.foo.com:8080'
|
|
|
|
|
> Ox.test.object.pathname
|
|
|
|
|
'/bar/index.html'
|
|
|
|
|
> Ox.test.object.port
|
|
|
|
|
'8080'
|
|
|
|
|
> Ox.test.object.protocol
|
|
|
|
|
'http:'
|
|
|
|
|
> Ox.test.object.search
|
|
|
|
|
'?a=0&b=1'
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.parseURL = (function() {
|
|
|
|
|
// fixme: leak memory, like now, or create every time? ... benchmark??
|
|
|
|
|
var a = document.createElement('a'),
|
|
|
|
|
keys = ['hash', 'host', 'hostname', 'origin',
|
|
|
|
|
'pathname', 'port', 'protocol', 'search'];
|
|
|
|
|
return function(str) {
|
|
|
|
|
var ret = {};
|
|
|
|
|
a.href = str;
|
|
|
|
|
keys.forEach(function(key) {
|
|
|
|
|
ret[key] = a[key];
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.parseURLs <f> Takes HTML and turns URLs into links
|
|
|
|
|
@*/
|
|
|
|
|
// fixme: is parseURLs the right name?
|
|
|
|
|
// fixme: no tests
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.parseURLs = function(html) {
|
|
|
|
|
return html.replace(
|
|
|
|
|
/\b((https?:\/\/|www\.).+?)([\.,:;!\?\)\]]*?(\s|$))/gi,
|
|
|
|
|
function(str, url, pre, end) {
|
|
|
|
|
url = (pre == 'www.' ? 'http://' : '' ) + url;
|
|
|
|
|
return Ox.formatString(
|
|
|
|
|
'<a href="{url}" title="{url}">{host}</a>{end}',
|
|
|
|
|
{
|
|
|
|
|
end: end,
|
|
|
|
|
host: Ox.parseURL(url).hostname,
|
|
|
|
|
url: url
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ JavaScript -----------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.doc <f> Generates documentation for annotated JavaScript
|
2011-05-07 15:56:29 +00:00
|
|
|
|
(file, callback) -> <u> undefined
|
|
|
|
|
file <s> JavaScript file
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
doc <[o]> Array of doc objects
|
|
|
|
|
arguments <[o]|u> Arguments (array of doc objects)
|
|
|
|
|
Present if the <code>type</code> of the item is
|
|
|
|
|
<code>"function"</code>.
|
|
|
|
|
description <s|u> Multi-line description with optional markup
|
|
|
|
|
See Ox.parseHTML for details
|
|
|
|
|
events <[o]|u> Events (array of doc objects)
|
|
|
|
|
Present if the item fires any events
|
|
|
|
|
file <s> File name
|
|
|
|
|
line <n> Line number
|
|
|
|
|
name <s> Name of the item
|
|
|
|
|
properties <[o]|u> Properties (array of doc objects)
|
|
|
|
|
Present if the <code>type</code> of the item is
|
|
|
|
|
<code>"event"</code>, <code>"function"</code>
|
|
|
|
|
or <code>"object"</code>.
|
|
|
|
|
section <s|u> Section in the file
|
|
|
|
|
source <[o]> Source code (array of tokens)
|
|
|
|
|
length <n> Length of the token
|
|
|
|
|
offset <n> Offset of the token
|
|
|
|
|
type <s> Type of the token
|
|
|
|
|
See Ox.tokenize for list of types
|
|
|
|
|
summary <s> One-line summary
|
|
|
|
|
usage <[o]> Usage (array of doc objects)
|
|
|
|
|
Present if the <code>type</code> of the item is
|
|
|
|
|
<code>"function"</code>.
|
|
|
|
|
type <s> Type of the item
|
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
(source) <a> Array of documentation objects
|
|
|
|
|
source <s> JavaScript source code
|
2011-05-07 15:56:29 +00:00
|
|
|
|
# > Ox.doc("//@ Ox.foo <string> just some string")
|
|
|
|
|
# [{"name": "Ox.foo", "summary": "just some string", "type": "string"}]
|
2011-05-06 23:30:32 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.doc = (function() {
|
|
|
|
|
var re = {
|
|
|
|
|
item: /^(.+?) <(.+?)> (.+)$/,
|
|
|
|
|
multiline: /^\/\*\@.*?\n([\w\W]+)\n.*?\@\*\/$/,
|
|
|
|
|
script: /\n(\s*<script>s*\n[\w\W]+\n\s*<\/script>s*)/g,
|
|
|
|
|
singleline: /^\/\/@\s*(.*?)\s*$/,
|
|
|
|
|
test: /\n(\s*> .+\n.+?)/g,
|
|
|
|
|
usage: /\(.*?\)/
|
|
|
|
|
},
|
|
|
|
|
types = {
|
|
|
|
|
a: 'array', b: 'boolean', d: 'date',
|
|
|
|
|
e: 'element', f: 'function', n: 'number',
|
|
|
|
|
o: 'object', r: 'regexp', s: 'string',
|
|
|
|
|
u: 'undefined', '*': 'any', '!': 'event'
|
2011-05-07 15:56:29 +00:00
|
|
|
|
};
|
|
|
|
|
function decodeLinebreaks(match, submatch) {
|
|
|
|
|
return (submatch || match).replace(/\u21A9/g, '\n');
|
|
|
|
|
}
|
|
|
|
|
function encodeLinebreaks(match, submatch) {
|
|
|
|
|
return '\n' + (submatch || match).replace(/\n/g, '\u21A9');
|
|
|
|
|
}
|
|
|
|
|
function getIndent(str) {
|
|
|
|
|
var indent = -1;
|
|
|
|
|
while (str[++indent] == ' ') {}
|
|
|
|
|
return indent;
|
|
|
|
|
}
|
|
|
|
|
function parseItem(str) {
|
|
|
|
|
var matches = re.item(str);
|
|
|
|
|
// to tell a variable with default value, like
|
|
|
|
|
// name <string|'<a href="...">foo</a>'> summary
|
|
|
|
|
// from a line of description with tags, like
|
|
|
|
|
// some <a href="...">description</a> text
|
|
|
|
|
// we need to check if there is either no forward slash
|
|
|
|
|
// or if the second last char is a single or double quote
|
|
|
|
|
return matches && (
|
|
|
|
|
matches[2].indexOf('/') == -1 ||
|
|
|
|
|
'\'"'.indexOf(matches[2].substr(-2, 1)) > -1
|
|
|
|
|
) ? Ox.extend({
|
|
|
|
|
name: parseName(matches[1].trim()),
|
|
|
|
|
summary: matches[3].trim()
|
|
|
|
|
}, parseType(matches[2])) : null;
|
|
|
|
|
}
|
|
|
|
|
function parseName(str) {
|
|
|
|
|
var matches = re.usage(str);
|
|
|
|
|
return matches ? matches[0] : str;
|
|
|
|
|
}
|
|
|
|
|
function parseNode(node) {
|
|
|
|
|
var item = parseItem(node.line), subitem;
|
|
|
|
|
Ox.print(node, node.line, 'item', item);
|
|
|
|
|
node.nodes && node.nodes.forEach(function(node) {
|
|
|
|
|
var key, line = node.line, subitem;
|
|
|
|
|
if (!/^#/.test(node.line)) {
|
|
|
|
|
if (/^<script>/.test(line)) {
|
|
|
|
|
item.examples = [parseScript(line)];
|
|
|
|
|
} else if (/^>/.test(line)) {
|
|
|
|
|
item.examples = item.examples || [];
|
|
|
|
|
item.examples.push(parseTest(line));
|
|
|
|
|
} else if ((subitem = parseItem(line))) {
|
|
|
|
|
if (/^\(/.test(subitem.name)) {
|
|
|
|
|
item.usage = item.usage || [];
|
|
|
|
|
item.usage.push(parseNode(node));
|
|
|
|
|
} else if (subitem.types[0] == 'event') {
|
|
|
|
|
item.events = item.events || [];
|
|
|
|
|
item.events.push(parseNode(node));
|
|
|
|
|
} else {
|
|
|
|
|
key = item.types[0] == 'function' ?
|
|
|
|
|
'arguments' : 'properties'
|
|
|
|
|
item[key] = item[key] || [];
|
|
|
|
|
item[key].push(parseNode(node));
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
item.description = item.description ?
|
|
|
|
|
item.description + ' ' + line : line
|
|
|
|
|
}
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
function parseScript(str) {
|
|
|
|
|
// remove script tags and extra indentation
|
|
|
|
|
var lines = decodeLinebreaks(str).split('\n'),
|
|
|
|
|
indent = getIndent(lines[1]);
|
|
|
|
|
return {
|
|
|
|
|
statement: Ox.map(lines, function(line, i) {
|
|
|
|
|
return i && i < lines.length - 1 ?
|
|
|
|
|
line.substr(indent) : null;
|
|
|
|
|
}).join('\n')
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
function parseTest(str) {
|
|
|
|
|
var lines = decodeLinebreaks(str).split('\n');
|
|
|
|
|
Ox.print('$$$', str)
|
|
|
|
|
return {
|
|
|
|
|
statement: lines[0].substr(2),
|
|
|
|
|
// result: JSON.parse(lines[1].trim())
|
|
|
|
|
result: lines[1].trim()
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
function parseTokens(tokens, includeLeading) {
|
|
|
|
|
var leading = [],
|
|
|
|
|
tokens_ = [];
|
|
|
|
|
tokens.forEach(function(token) {
|
|
|
|
|
if (['linebreak', 'whitespace'].indexOf(token.type) > -1) {
|
|
|
|
|
includeLeading && leading.push(token);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
} else {
|
2011-05-07 15:56:29 +00:00
|
|
|
|
tokens_ = Ox.merge(tokens_, leading, [token]);
|
|
|
|
|
leading = [];
|
|
|
|
|
includeLeading = true;
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
return tokens_;
|
|
|
|
|
}
|
|
|
|
|
function parseTree(lines) {
|
|
|
|
|
// parses indented lines into a tree structure, like
|
|
|
|
|
// {line: "...", nodes: [{line: "...", nodes: [...]}]}
|
|
|
|
|
var branches = [],
|
|
|
|
|
indent,
|
|
|
|
|
node = {
|
|
|
|
|
// chop the root line
|
|
|
|
|
line: lines.shift().trim()
|
|
|
|
|
};
|
|
|
|
|
if (lines.length) {
|
|
|
|
|
indent = getIndent(lines[0]);
|
|
|
|
|
lines.forEach(function(line) {
|
|
|
|
|
if (getIndent(line) == indent) {
|
|
|
|
|
// line is a child,
|
|
|
|
|
// make it the root line of a new branch
|
|
|
|
|
branches.push([line]);
|
|
|
|
|
} else {
|
|
|
|
|
// line is a descendant of the last child,
|
|
|
|
|
// add it to the last branch
|
|
|
|
|
branches[branches.length - 1].push(line);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
node.nodes = branches.map(function(lines) {
|
|
|
|
|
return parseTree(lines);
|
|
|
|
|
});
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
2011-05-07 15:56:29 +00:00
|
|
|
|
return node;
|
|
|
|
|
}
|
|
|
|
|
function parseType(str) {
|
|
|
|
|
// returns {types: [""]}
|
|
|
|
|
// or {types: [""], default: ""}
|
|
|
|
|
// or {types: [""], parent: ""}
|
|
|
|
|
var isArray,
|
|
|
|
|
ret = {types: []},
|
|
|
|
|
split,
|
|
|
|
|
type;
|
|
|
|
|
// only split by ':' if there is no default string value
|
|
|
|
|
if ('\'"'.indexOf(str.substr(-2, 1)) == -1) {
|
|
|
|
|
split = str.split(':');
|
|
|
|
|
str = split[0];
|
|
|
|
|
if (split.length == 2) {
|
|
|
|
|
ret.parent = split[1];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
str.split('|').forEach(function(str) {
|
|
|
|
|
var unwrapped = unwrap(str);
|
|
|
|
|
if (unwrapped in types) {
|
|
|
|
|
ret.types.push(wrap(types[unwrapped]))
|
|
|
|
|
} else if (
|
|
|
|
|
(type = Ox.filter(Ox.values(types), function(type) {
|
|
|
|
|
return Ox.startsWith(type, unwrapped);
|
|
|
|
|
})).length
|
|
|
|
|
) {
|
|
|
|
|
ret.types.push(wrap(type[0]));
|
|
|
|
|
} else {
|
|
|
|
|
ret['default'] = str;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
function unwrap(str) {
|
|
|
|
|
return (isArray = /^\[.+\]$/.test(str)) ?
|
|
|
|
|
str = str.substr(1, str.length - 2) : str;
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
2011-05-07 15:56:29 +00:00
|
|
|
|
function wrap(str) {
|
|
|
|
|
return isArray ?
|
|
|
|
|
'array[' + str + (str != 'any' ? 's' : '') + ']' : str;
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
2011-05-07 15:56:29 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
return function(file, callback) {
|
|
|
|
|
Ox.get(file, function(source) {
|
|
|
|
|
var blocks = [],
|
|
|
|
|
items = [],
|
|
|
|
|
section = '',
|
|
|
|
|
tokens = [];
|
|
|
|
|
Ox.tokenize(source).forEach(function(token) {
|
|
|
|
|
var match;
|
|
|
|
|
token.source = source.substr(token.offset, token.length);
|
|
|
|
|
if (token.type == 'comment' && (match =
|
|
|
|
|
re.multiline(token.source) || re.singleline(token.source)
|
|
|
|
|
)) {
|
|
|
|
|
blocks.push(match[1]);
|
|
|
|
|
tokens.push([]);
|
|
|
|
|
} else if (tokens.length) {
|
|
|
|
|
tokens[tokens.length - 1].push(token);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*
|
|
|
|
|
var blocks = Ox.map(Ox.tokenize(source), function(token) {
|
|
|
|
|
// filter out tokens that are not comments
|
|
|
|
|
// or don't match the doc comment pattern
|
|
|
|
|
var match;
|
|
|
|
|
token.source = source.substr(token.offset, token.length);
|
|
|
|
|
return token.type == 'comment' && (match =
|
|
|
|
|
re.multiline(token.source) || re.singleline(token.source)
|
|
|
|
|
) ? match[1] : null;
|
|
|
|
|
}),
|
|
|
|
|
items = [];
|
|
|
|
|
*/
|
|
|
|
|
blocks.forEach(function(block, i) {
|
|
|
|
|
var item, lastItem,
|
|
|
|
|
lines = block
|
|
|
|
|
.replace(re.script, encodeLinebreaks)
|
|
|
|
|
.replace(re.test, encodeLinebreaks)
|
|
|
|
|
.split('\n'),
|
|
|
|
|
tree = parseTree(lines);
|
|
|
|
|
if (re.item.test(tree.line)) {
|
|
|
|
|
// parse the tree's root node
|
|
|
|
|
item = parseNode(tree);
|
|
|
|
|
item.file = file;
|
|
|
|
|
if (section) {
|
|
|
|
|
item.section = section;
|
|
|
|
|
}
|
|
|
|
|
if (/^[A-Z]/.test(item.name)) {
|
|
|
|
|
// main item
|
|
|
|
|
item.source = parseTokens(tokens[i]);
|
2011-05-07 21:07:53 +00:00
|
|
|
|
item.line = source.substr(0, item.source[0].offset)
|
|
|
|
|
.split('\n').length;
|
2011-05-07 15:56:29 +00:00
|
|
|
|
items.push(item);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
} else {
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// property of a function item
|
|
|
|
|
lastItem = items[items.length - 1];
|
|
|
|
|
lastItem.properties = lastItem.properties || [];
|
|
|
|
|
lastItem.properties.push(item);
|
|
|
|
|
// include leading linebreaks and whitespace
|
|
|
|
|
lastItem.source = Ox.merge(
|
|
|
|
|
lastItem.source, parseTokens(tokens[i], true)
|
|
|
|
|
);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
} else {
|
2011-05-07 15:56:29 +00:00
|
|
|
|
section = tree.line.split(' ')[0]
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-07 15:56:29 +00:00
|
|
|
|
callback(items);
|
|
|
|
|
});
|
|
|
|
|
}
|
2011-05-06 23:30:32 +00:00
|
|
|
|
}());
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.minify <f> Minifies JavaScript (experimental!)
|
|
|
|
|
@*/
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.minify = function(source) {
|
|
|
|
|
var tokens = Ox.tokenize(source)
|
|
|
|
|
return Ox.map(tokens, function(token, i) {
|
|
|
|
|
var ret = source.substr(token.offset, token.type == 'whitespace' ? 1 : token.length);
|
|
|
|
|
if (token.type == 'comment') {
|
|
|
|
|
ret = null;
|
|
|
|
|
} else if (
|
|
|
|
|
token.type == 'linebreak' && (
|
|
|
|
|
i == 0 || i == tokens.length - 1 ||
|
|
|
|
|
tokens[i - 1].type == 'linebreak' ||
|
|
|
|
|
tokens[i + 1].type == 'linebreak'
|
|
|
|
|
)
|
|
|
|
|
) {
|
|
|
|
|
ret = null;
|
|
|
|
|
} else if (
|
|
|
|
|
token.type == 'whitespace' && (
|
|
|
|
|
i == 0 || i == tokens.length - 1 ||
|
|
|
|
|
tokens[i - 1].type != 'keyword' || (
|
|
|
|
|
tokens[i + 1].type == 'operator'
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
) {
|
|
|
|
|
ret = null;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}).join('');
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.test <f> Takes JavaScript, runs inline tests, returns results
|
|
|
|
|
@*/
|
2011-05-07 17:25:34 +00:00
|
|
|
|
Ox.test = function(file, callback) {
|
|
|
|
|
Ox.doc(file, function(items) {
|
|
|
|
|
var tests = [];
|
|
|
|
|
items.forEach(function(item) {
|
|
|
|
|
item.examples && item.examples.forEach(function(example) {
|
|
|
|
|
Ox.print(example)
|
|
|
|
|
var actual = eval(example.statement);
|
|
|
|
|
if (example.result) {
|
|
|
|
|
tests.push({
|
|
|
|
|
actual: actual,
|
|
|
|
|
expected: example.result,
|
|
|
|
|
name: item.name,
|
|
|
|
|
section: item.section,
|
|
|
|
|
statement: example.statement,
|
|
|
|
|
success: Ox.isEqual(eval('Ox.test.result = ' + example.result), actual)
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
2011-05-06 23:30:32 +00:00
|
|
|
|
});
|
2011-05-07 17:25:34 +00:00
|
|
|
|
callback(tests);
|
2011-05-06 23:30:32 +00:00
|
|
|
|
});
|
2011-05-07 17:25:34 +00:00
|
|
|
|
};
|
2011-05-06 23:30:32 +00:00
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.tokenize <f> Tokenizes JavaScript
|
|
|
|
|
(source) -> <[o]> Array of tokens
|
|
|
|
|
length <n> Length of the token
|
|
|
|
|
offset <n> Offset of the token
|
|
|
|
|
type <s> Type of the token
|
|
|
|
|
Type can be <code>"comment"</code>, <code>"constant"</code>,
|
|
|
|
|
<code>"identifier"</code>, <code>"keyword"</code>,
|
|
|
|
|
<code>"linebreak"</code>, <code>"method"</code>,
|
|
|
|
|
<code>"number"</code>, <code>"object"</code>,
|
|
|
|
|
<code>"operator"</code>, <code>"property"</code>,
|
|
|
|
|
<code>"regexp"</code>, <code>"string"</code>
|
|
|
|
|
or <code>"whitespace"</code>
|
|
|
|
|
source <s> JavaScript source code
|
|
|
|
|
@*/
|
|
|
|
|
Ox.tokenize = (function() {
|
|
|
|
|
|
|
|
|
|
// see https://github.com/mozilla/narcissus/blob/master/lib/jslex.js
|
|
|
|
|
// and https://developer.mozilla.org/en/JavaScript/Reference
|
|
|
|
|
|
|
|
|
|
var identifier = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_',
|
|
|
|
|
linebreak = '\n\r',
|
|
|
|
|
number = '0123456789',
|
|
|
|
|
operator = [
|
|
|
|
|
// arithmetic
|
|
|
|
|
'+', '-', '*', '/', '%', '++', '--',
|
|
|
|
|
// assignment
|
|
|
|
|
'=', '+=', '-=', '*=', '/=', '%=',
|
|
|
|
|
'&=', '|=', '^=', '<<=', '>>=', '>>>=',
|
|
|
|
|
// bitwise
|
|
|
|
|
'&', '|', '^', '~', '<<', '>>', '>>>',
|
|
|
|
|
// comparison
|
|
|
|
|
'==', '!=', '===', '!==', '>', '>=', '<', '<=',
|
|
|
|
|
// conditional
|
|
|
|
|
'?', ':',
|
|
|
|
|
// grouping
|
|
|
|
|
'(', ')', '[', ']', '{', '}',
|
|
|
|
|
// logical
|
|
|
|
|
'&&', '||', '!',
|
|
|
|
|
// other
|
|
|
|
|
'.', ',', ';'
|
|
|
|
|
],
|
|
|
|
|
whitespace = ' \t',
|
|
|
|
|
word = {
|
|
|
|
|
constant: [
|
|
|
|
|
// Math
|
|
|
|
|
'E', 'LN2', 'LN10', 'LOG2E', 'LOG10E', 'PI', 'SQRT1_2', 'SQRT2',
|
|
|
|
|
// Number
|
|
|
|
|
'MAX_VALUE', 'MIN_VALUE', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY'
|
|
|
|
|
],
|
|
|
|
|
keyword: [
|
|
|
|
|
'break',
|
|
|
|
|
'case', 'catch', 'class', 'const', 'continue',
|
|
|
|
|
'debugger', 'default', 'delete', 'do',
|
|
|
|
|
'else', 'enum', 'export', 'extends',
|
|
|
|
|
'false', 'finally', 'for', 'function',
|
|
|
|
|
'if', 'implements', 'import', 'in', 'instanceof', 'interface',
|
|
|
|
|
'let', 'module',
|
|
|
|
|
'new', 'null',
|
|
|
|
|
'package', 'private', 'protected', 'public',
|
|
|
|
|
'return',
|
|
|
|
|
'super', 'switch', 'static',
|
|
|
|
|
'this', 'throw', 'true', 'try', 'typeof',
|
|
|
|
|
'var', 'void',
|
|
|
|
|
'yield',
|
|
|
|
|
'while', 'with',
|
|
|
|
|
],
|
|
|
|
|
method: [
|
|
|
|
|
// Array
|
|
|
|
|
'concat',
|
|
|
|
|
'every',
|
|
|
|
|
'filter', 'forEach',
|
|
|
|
|
'join',
|
|
|
|
|
'lastIndexOf',
|
|
|
|
|
'indexOf', 'isArray',
|
|
|
|
|
'map',
|
|
|
|
|
'pop', 'push',
|
|
|
|
|
'reduce', 'reduceRight', 'reverse',
|
|
|
|
|
'shift', 'slice', 'some', 'sort', 'splice',
|
|
|
|
|
'unshift',
|
|
|
|
|
// Date
|
|
|
|
|
'getDate', 'getDay', 'getFullYear', 'getHours', 'getMilliseconds',
|
|
|
|
|
'getMinutes', 'getMonth', 'getSeconds', 'getTime', 'getTimezoneOffset',
|
|
|
|
|
'getUTCDate', 'getUTCDay', 'getUTCFullYear', 'getUTCHours', 'getUTCMilliseconds',
|
|
|
|
|
'getUTCMinutes', 'getUTCMonth', 'getUTCSeconds',
|
|
|
|
|
'now',
|
|
|
|
|
'parse',
|
|
|
|
|
'setDate', 'setFullYear', 'setHours', 'setMilliseconds', 'setMinutes',
|
|
|
|
|
'setMonth', 'setSeconds', 'setTime',
|
|
|
|
|
'setUTCDate', 'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes',
|
|
|
|
|
'setUTCMonth', 'setUTCSeconds',
|
|
|
|
|
'toDateString', 'toJSON', 'toLocaleDateString', 'toLocaleString', 'toLocaleTimeString',
|
|
|
|
|
'toTimeString', 'toUTCString',
|
|
|
|
|
'UTC',
|
|
|
|
|
// Function
|
|
|
|
|
'apply', 'bind', 'call', 'isGenerator',
|
|
|
|
|
// JSON
|
|
|
|
|
'parse', 'stringify',
|
|
|
|
|
// Math
|
|
|
|
|
'abs', 'acos', 'asin', 'atan', 'atan2',
|
|
|
|
|
'ceil', 'cos',
|
|
|
|
|
'exp',
|
|
|
|
|
'floor',
|
|
|
|
|
'log',
|
|
|
|
|
'max', 'min',
|
|
|
|
|
'pow',
|
|
|
|
|
'random', 'round',
|
|
|
|
|
'sin', 'sqrt',
|
|
|
|
|
'tan',
|
|
|
|
|
// Number
|
|
|
|
|
'toExponential', 'toFixed', 'toLocaleString', 'toPrecision',
|
|
|
|
|
// Object
|
|
|
|
|
'create',
|
|
|
|
|
'defineProperty', 'defineProperties',
|
|
|
|
|
'freeze',
|
|
|
|
|
'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'getPrototypeOf',
|
|
|
|
|
'hasOwnProperty',
|
|
|
|
|
'isExtensible', 'isFrozen', 'isPrototypeOf', 'isSealed',
|
|
|
|
|
'keys',
|
|
|
|
|
'preventExtensions', 'propertyIsEnumerable',
|
|
|
|
|
'seal',
|
|
|
|
|
'toLocaleString', 'toString',
|
|
|
|
|
'valueOf',
|
|
|
|
|
// RegExp
|
|
|
|
|
'exec', 'test',
|
|
|
|
|
// String
|
|
|
|
|
'charAt', 'charCodeAt', 'concat',
|
|
|
|
|
'fromCharCode',
|
|
|
|
|
'indexOf',
|
|
|
|
|
'lastIndexOf', 'localeCompare',
|
|
|
|
|
'match',
|
|
|
|
|
'replace',
|
|
|
|
|
'search', 'slice', 'split', 'substr', 'substring',
|
|
|
|
|
'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toUpperCase', 'trim'
|
|
|
|
|
],
|
|
|
|
|
object: [
|
|
|
|
|
'Array',
|
|
|
|
|
'Boolean',
|
|
|
|
|
'Date', 'decodeURI', 'decodeURIComponent',
|
|
|
|
|
'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError',
|
|
|
|
|
'Function',
|
|
|
|
|
'Infinity', 'isFinite', 'isNaN',
|
|
|
|
|
'JSON',
|
|
|
|
|
'Math',
|
|
|
|
|
'NaN', 'Number',
|
|
|
|
|
'Object',
|
|
|
|
|
'parseFloat', 'parseInt',
|
|
|
|
|
'RangeError', 'ReferenceError', 'RegExp',
|
|
|
|
|
'String', 'SyntaxError',
|
|
|
|
|
'TypeError',
|
|
|
|
|
'undefined', 'URIError',
|
|
|
|
|
'window'
|
|
|
|
|
],
|
|
|
|
|
property: [
|
|
|
|
|
// Function
|
|
|
|
|
'constructor', 'length', 'prototype',
|
|
|
|
|
// RegExp
|
|
|
|
|
'global', 'ignoreCase', 'lastIndex', 'multiline', 'source'
|
|
|
|
|
]
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return function(source) {
|
|
|
|
|
|
|
|
|
|
//source = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
|
|
|
|
|
|
|
|
|
|
var cursor = 0,
|
|
|
|
|
tokenize = {
|
|
|
|
|
comment: function() {
|
|
|
|
|
while (char = source[++cursor]) {
|
|
|
|
|
if (next == '/' && char == '\n') {
|
|
|
|
|
break;
|
|
|
|
|
} else if (next == '*' && char == '*' && source[cursor + 1] == '/') {
|
|
|
|
|
cursor += 2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
identifier: function() {
|
|
|
|
|
var str;
|
|
|
|
|
while (identifier.indexOf(source[++cursor]) > -1) {}
|
|
|
|
|
str = source.substring(start, cursor);
|
|
|
|
|
Ox.forEach(word, function(value, key) {
|
|
|
|
|
if (value.indexOf(str) > -1) {
|
|
|
|
|
type = key;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
linebreak: function() {
|
|
|
|
|
while (linebreak.indexOf(source[++cursor]) > -1) {}
|
|
|
|
|
},
|
|
|
|
|
number: function() {
|
|
|
|
|
while ((number + '.').indexOf(source[++cursor]) > -1) {}
|
|
|
|
|
},
|
|
|
|
|
operator: function() {
|
|
|
|
|
if (operator.indexOf(char + source[++cursor]) > -1) {
|
|
|
|
|
if (operator.indexOf(char + next + source[++cursor]) > 1) {
|
|
|
|
|
++cursor;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
regexp: function() {
|
|
|
|
|
while ((char = source[++cursor]) != '/') {
|
|
|
|
|
char == '\\' && ++cursor;
|
|
|
|
|
if (cursor == source.length) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
while (identifier.indexOf(source[++cursor]) > -1) {}
|
|
|
|
|
},
|
|
|
|
|
string: function() {
|
|
|
|
|
var delimiter = char;
|
|
|
|
|
while ((char = source[++cursor]) != delimiter) {
|
|
|
|
|
char == '\\' && ++cursor;
|
|
|
|
|
if (cursor == source.length) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
++cursor;
|
|
|
|
|
},
|
|
|
|
|
whitespace: function() {
|
|
|
|
|
while (whitespace.indexOf(source[++cursor]) > -1) {}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
tokens = [],
|
|
|
|
|
type;
|
|
|
|
|
|
|
|
|
|
while (cursor < source.length) {
|
|
|
|
|
var char = source[cursor],
|
|
|
|
|
next = source[cursor + 1],
|
|
|
|
|
start = cursor;
|
|
|
|
|
if (char == '/' && (next == '/' || next == '*')) {
|
|
|
|
|
type = 'comment';
|
|
|
|
|
} else if (identifier.indexOf(char) > -1) {
|
|
|
|
|
type = 'identifier';
|
|
|
|
|
} else if (linebreak.indexOf(char) > -1) {
|
|
|
|
|
type = 'linebreak';
|
|
|
|
|
} else if (number.indexOf(char) > -1) {
|
|
|
|
|
type = 'number';
|
|
|
|
|
} else if (char == "'" || char == '"') {
|
|
|
|
|
type = 'string';
|
|
|
|
|
} else if (whitespace.indexOf(char) > -1) {
|
|
|
|
|
type = 'whitespace';
|
|
|
|
|
} else if (char == '/') {
|
|
|
|
|
type = isRegExp() ? 'regexp' : 'operator';
|
|
|
|
|
} else if (operator.indexOf(char) > -1) {
|
|
|
|
|
type = 'operator';
|
|
|
|
|
}
|
|
|
|
|
tokenize[type]();
|
|
|
|
|
tokens.push({
|
|
|
|
|
length: cursor - start,
|
|
|
|
|
offset: start,
|
|
|
|
|
type: type,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function isRegExp() {
|
|
|
|
|
// checks if a forward slash is the beginning of a regexp,
|
|
|
|
|
// as opposed to the beginning of an operator
|
|
|
|
|
// see http://www.mozilla.org/js/language/js20-2000-07/rationale/syntax.html#regular-expressions
|
|
|
|
|
var index = tokens.length,
|
|
|
|
|
isRegExp = false
|
|
|
|
|
offset = 0;
|
|
|
|
|
// scan back to the previous significant token,
|
|
|
|
|
// or the beginning of the source
|
|
|
|
|
while (
|
|
|
|
|
typeof tokens[--index] != 'undefined' &&
|
|
|
|
|
['comment', 'linebreak', 'whitespace'].indexOf(tokens[index].type) > -1
|
|
|
|
|
) {
|
|
|
|
|
offset += tokens[index].length;
|
|
|
|
|
}
|
|
|
|
|
if (typeof tokens[index] == 'undefined') {
|
|
|
|
|
// source begins with forward slash
|
|
|
|
|
isRegExp = true;
|
|
|
|
|
} else {
|
|
|
|
|
prevToken = tokens[index];
|
|
|
|
|
prevString = source.substr(cursor - prevToken.length - offset, prevToken.length);
|
|
|
|
|
isRegExp = (
|
|
|
|
|
prevToken.type == 'keyword' &&
|
|
|
|
|
['false', 'null', 'true'].indexOf(prevString) == -1
|
|
|
|
|
) || (
|
|
|
|
|
prevToken.type == 'operator' &&
|
|
|
|
|
['++', '--', ')', ']', '}'].indexOf(prevString) == -1
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
return isRegExp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return tokens;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}());
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Math -----------------------------------------------------------------------
|
2011-05-06 23:30:32 +00:00
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.asinh <f> Inverse hyperbolic sine
|
|
|
|
|
Strangely missing from <code>Math</code>.
|
|
|
|
|
@*/
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.asinh = function(x) {
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// fixme: no test
|
2011-05-06 23:30:32 +00:00
|
|
|
|
return Math.log(x + Math.sqrt(x * x + 1));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.deg <f> Takes radians, returns degrees
|
|
|
|
|
Strangely missing from <code>Math</code>.
|
|
|
|
|
> Ox.deg(2 * Math.PI)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
360
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.deg = function(rad) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return rad * 180 / Math.PI;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.divideInt <f> Divides a number by another and returns an array of integers
|
|
|
|
|
<code>Ox.divideInt(num, by)</code> returns an array of "as equal as
|
|
|
|
|
possible" integers that has a sum of <code>num</code> and a length of
|
|
|
|
|
<code>by</code>.
|
|
|
|
|
> Ox.divideInt(100, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[33, 33, 34]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.divideInt(100, 6)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
[16, 16, 17, 17, 17, 17]
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.divideInt = function(num, by) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var arr = [],
|
|
|
|
|
div = parseInt(num / by),
|
|
|
|
|
mod = num % by,
|
|
|
|
|
i;
|
|
|
|
|
for (i = 0; i < by; i++) {
|
|
|
|
|
arr[i] = div + (i > by - 1 - mod);
|
|
|
|
|
}
|
|
|
|
|
return arr;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
2011-05-07 21:07:53 +00:00
|
|
|
|
Ox.limit <f> Limits a number by a given mininum and maximum
|
|
|
|
|
<code>Ox.limit(num, min, max)</code> is a shorthand for
|
|
|
|
|
<code>Math.min(Math.max(num, min), max)</code>
|
2011-05-07 15:56:29 +00:00
|
|
|
|
(num) -> <n> <code>num</code>
|
|
|
|
|
(num, max) -> <n> <code>Math.max(num, max)</code>
|
|
|
|
|
(num, min, max) -> <n> <code>Math.min(Math.max(num, min), max)</code>
|
|
|
|
|
num <n> number
|
|
|
|
|
min <n> minimum
|
|
|
|
|
max <n> maximum
|
|
|
|
|
> Ox.limit(1, 2, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
2
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.limit(4, 2, 3)
|
|
|
|
|
3
|
|
|
|
|
> Ox.limit(2, 1)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.limit = function(num, min, max) {
|
|
|
|
|
// fixme: rewrite this
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var len = arguments.length;
|
|
|
|
|
max = arguments[len - 1];
|
|
|
|
|
min = len == 3 ? min : 0;
|
|
|
|
|
return Math.min(Math.max(num, min), max);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.log <f> Returns the logarithm of a given number to a given base
|
|
|
|
|
Strangely missing from <code>Math</code>.
|
|
|
|
|
> Ox.log(100, 10)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
2
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.log(Math.E)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.log = function(num, base) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return Math.log(num) / Math.log(base || Math.E);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.mod <f> Modulo function
|
|
|
|
|
Unlike <code>-1 % 10</code>, which returns <code>-1</code>,
|
|
|
|
|
<code>Ox.mod(-1, 10)</code> returns <code>9</code>.
|
|
|
|
|
> Ox.mod(11, 10)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
1
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.mod(-11, 10)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
9
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.mod = function(num, by) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var mod = num % by;
|
|
|
|
|
return mod >= 0 ? mod : mod + by;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.rad <f> Takes degrees, returns radians
|
|
|
|
|
Strangely missing from <code>Math</code>.
|
|
|
|
|
> Ox.rad(360)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
2 * Math.PI
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.rad = function(deg) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return deg * Math.PI / 180;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.random <f> Returns a random integer
|
|
|
|
|
> [0, 1, 2, 3].indexOf(Ox.random(3)) > -1
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> [1, 2].indexOf(Ox.random(1, 2)) > -1
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-07 15:56:29 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.random = function() {
|
|
|
|
|
// FIXME: weird, reimplement with Ox.loop / Ox.range
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var len = arguments.length,
|
|
|
|
|
min = len == 1 ? 0 : arguments[0],
|
|
|
|
|
max = arguments[len - 1];
|
|
|
|
|
return min + parseInt(Math.random() * (max - min + 1));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.round <f> Rounds a number with a given number of decimals
|
|
|
|
|
> Ox.round(2 / 3, 6)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0.666667
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.round(1 / 2, 3)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
0.5
|
2011-05-07 15:56:29 +00:00
|
|
|
|
> Ox.round(1 / 2)
|
|
|
|
|
1
|
|
|
|
|
@*/
|
|
|
|
|
Ox.round = function(num, dec) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
var pow = Math.pow(10, dec || 0);
|
|
|
|
|
return Math.round(num * pow) / pow;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.sinh <f> Hyperbolic sine
|
|
|
|
|
Strangely missing from <code>Math</code>.
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.sinh = function(x) {
|
2011-05-07 15:56:29 +00:00
|
|
|
|
// fixme: no test
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return (Math.exp(x) - Math.exp(-x)) / 2;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Constants ------------------------------------------------------------------
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.MAX_LATITUDE = Ox.deg(Math.atan(Ox.sinh(Math.PI)));
|
|
|
|
|
Ox.MIN_LATITUDE = -Ox.MAX_LATITUDE;
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Object ---------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.extend <function> Extends an object with one or more other objects
|
|
|
|
|
> Ox.extend({a: 1, b: 1, c: 1}, {b: 2, c: 2}, {c: 3})
|
|
|
|
|
{a: 1, b: 2, c: 3}
|
|
|
|
|
@*/
|
|
|
|
|
Ox.extend = function() {
|
|
|
|
|
var obj = arguments[0];
|
|
|
|
|
Ox.forEach(Array.prototype.slice.call(arguments, 1), function(arg, i) {
|
|
|
|
|
Ox.forEach(arg, function(val, key) {
|
|
|
|
|
obj[key] = val;
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
return obj;
|
|
|
|
|
};
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
|
|
|
|
================================================================================
|
2011-05-06 23:30:32 +00:00
|
|
|
|
RegExp functions
|
|
|
|
|
================================================================================
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
Ox.regexp = {
|
|
|
|
|
'accents': '¨´`ˆ˜',
|
|
|
|
|
'letters': 'a-z¨´`ˆ˜äåáà âãæçëéèèñïÃìîöóòôõøœßúùûÿ'
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Requests -------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.get <f> Get a remote file
|
|
|
|
|
# fixme: remote? same-origin-policy? jsonp?
|
|
|
|
|
(url, callback) -> <u> undefined
|
|
|
|
|
url <s> Remote URL
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
data <s> The contents of the remote resource
|
|
|
|
|
@*/
|
|
|
|
|
Ox.get = function(url, callback) {
|
|
|
|
|
var req = new XMLHttpRequest();
|
|
|
|
|
req.open('GET', url, true);
|
|
|
|
|
req.onreadystatechange = function() {
|
|
|
|
|
if (req.readyState == 4) {
|
|
|
|
|
if (req.status == 200) {
|
|
|
|
|
callback(req.responseText);
|
|
|
|
|
} else {
|
|
|
|
|
throw new Error('URL ' + url + ', status ' + req.status);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
req.send();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.getJSON <f> Get and parse a remote JSON file
|
|
|
|
|
# fixme: remote? same-origin-policy? jsonp?
|
|
|
|
|
(url, callback) -> <u> undefined
|
|
|
|
|
url <s> Remote URL
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
data <s> The contents of the remote resource
|
|
|
|
|
@*/
|
|
|
|
|
Ox.getJSON = function(url, callback) {
|
|
|
|
|
Ox.get(url, function(data) {
|
|
|
|
|
callback(JSON.parse(data));
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*@
|
|
|
|
|
Ox.loadFile <f> Loads a file (image, script or stylesheet)
|
|
|
|
|
(file="script.js", callback) -> <u> undefined
|
|
|
|
|
(file="stylesheet.css", callback) -> <u> undefined
|
|
|
|
|
(file="image.png", callback) -> <e> DOM element
|
|
|
|
|
file <s> Local path or remote URL
|
|
|
|
|
callback <f> Callback function
|
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.loadFile = (function() {
|
|
|
|
|
// fixme: this doesn't handle errors yet
|
|
|
|
|
// fixme: rename to getFile?
|
|
|
|
|
var cache = {};
|
|
|
|
|
return function (file, callback) {
|
|
|
|
|
var element,
|
|
|
|
|
request,
|
|
|
|
|
type = file.split('.').pop();
|
|
|
|
|
isImage = type != 'css' && type != 'js';
|
|
|
|
|
if (!cache[file]) {
|
|
|
|
|
if (isImage) {
|
|
|
|
|
element = new Image();
|
|
|
|
|
element.onload = addFileToCache;
|
|
|
|
|
element.src = file;
|
|
|
|
|
} else {
|
|
|
|
|
if (!findFileInHead()) {
|
|
|
|
|
element = document.createElement(
|
|
|
|
|
type == 'css' ? 'link' : 'script'
|
|
|
|
|
);
|
|
|
|
|
element[type == 'css' ? 'href' : 'src'] = file;
|
|
|
|
|
element.type = type == 'css' ?
|
|
|
|
|
'text/css' : 'text/javascript';
|
|
|
|
|
if (type == 'css') {
|
|
|
|
|
element.rel = 'stylesheet';
|
|
|
|
|
waitForCSS();
|
|
|
|
|
} else {
|
|
|
|
|
element.onload = addFileToCache;
|
|
|
|
|
}
|
|
|
|
|
document.head.appendChild(element);
|
|
|
|
|
} else {
|
|
|
|
|
addFileToCache();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
callback();
|
|
|
|
|
}
|
|
|
|
|
function addFileToCache() {
|
|
|
|
|
if (isImage) {
|
|
|
|
|
// for an image, save the element itself,
|
|
|
|
|
// so that it remains in the browser cache
|
|
|
|
|
cache['file'] = element;
|
|
|
|
|
callback(element);
|
|
|
|
|
} else {
|
|
|
|
|
cache['file'] = true;
|
|
|
|
|
callback();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
function findFileInHead() {
|
|
|
|
|
return Array.prototype.slice.apply(
|
|
|
|
|
document.getElementsByTagName(type == 'css' ? 'link' : 'script')
|
|
|
|
|
).map(function(element) {
|
|
|
|
|
return element[type == 'css' ? 'href' : 'src'] == file;
|
|
|
|
|
}).reduce(function(prev, curr) {
|
|
|
|
|
return prev || curr;
|
|
|
|
|
}, false);
|
|
|
|
|
}
|
|
|
|
|
function waitForCSS() {
|
|
|
|
|
var error = false;
|
|
|
|
|
try {
|
|
|
|
|
element.sheet.cssRule;
|
|
|
|
|
} catch(e) {
|
|
|
|
|
error = true;
|
|
|
|
|
setTimeout(function() {
|
|
|
|
|
waitForCSS();
|
|
|
|
|
}, 25);
|
|
|
|
|
}
|
|
|
|
|
!error && addFileToCache();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
}());
|
|
|
|
|
|
|
|
|
|
//@ String ---------------------------------------------------------------------
|
2011-05-06 23:30:32 +00:00
|
|
|
|
|
|
|
|
|
Ox.basename = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
2011-05-06 23:30:32 +00:00
|
|
|
|
fixme: this should go into Path functions
|
|
|
|
|
>>> Ox.basename("foo/bar/foo.bar")
|
|
|
|
|
"foo.bar"
|
|
|
|
|
>>> Ox.basename("foo.bar")
|
|
|
|
|
"foo.bar"
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
2011-05-06 23:30:32 +00:00
|
|
|
|
return str.replace(/^.*[\/\\]/g, '');
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.char = String.fromCharCode;
|
|
|
|
|
|
|
|
|
|
Ox.clean = function(str) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
2011-05-06 23:30:32 +00:00
|
|
|
|
>>> Ox.clean("foo bar")
|
|
|
|
|
"foo bar"
|
|
|
|
|
>>> Ox.clean(" foo bar ")
|
|
|
|
|
"foo bar"
|
|
|
|
|
>>> Ox.clean(" foo \n bar ")
|
|
|
|
|
"foo\nbar"
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
2011-05-06 23:30:32 +00:00
|
|
|
|
return Ox.map(str.split('\n'), function(str) {
|
|
|
|
|
return Ox.trim(str.replace(/\s+/g, ' '));
|
|
|
|
|
}).join('\n');
|
2011-04-27 19:39:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.contains = function(str, chr) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.contains("foo", "bar")
|
|
|
|
|
false
|
|
|
|
|
>>> Ox.contains("foobar", "bar")
|
|
|
|
|
true
|
|
|
|
|
>>> Ox.contains(['foo', 'bar'], 'foo')
|
|
|
|
|
true
|
|
|
|
|
// fixme: rename to Ox.has or Ox.isIn?
|
|
|
|
|
// then it'd become convenient for arrays
|
|
|
|
|
*/
|
|
|
|
|
return str.indexOf(chr) > -1;
|
2011-05-06 22:47:17 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.endsWith = function(str, sub) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.endsWith("foobar", "bar")
|
|
|
|
|
true
|
|
|
|
|
*/
|
|
|
|
|
return new RegExp(sub + '$').test(str);
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.highlight = function(txt, str) {
|
|
|
|
|
// fixme: move to ox.ui
|
|
|
|
|
return str ? txt.replace(
|
|
|
|
|
new RegExp('(' + str + ')', 'ig'),
|
|
|
|
|
'<span class="OxHighlight">$1</span>'
|
|
|
|
|
) : txt;
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.isValidEmail = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.isValidEmail("foo@bar.com")
|
|
|
|
|
true
|
|
|
|
|
>>> Ox.isValidEmail("foo.bar@foobar.co.uk")
|
|
|
|
|
true
|
|
|
|
|
>>> Ox.isValidEmail("foo@bar")
|
|
|
|
|
false
|
|
|
|
|
>>> Ox.isValidEmail("foo@bar..com")
|
|
|
|
|
false
|
|
|
|
|
*/
|
|
|
|
|
return !!/^[0-9A-Z\.\+\-_]+@(?:[0-9A-Z\-]+\.)+[A-Z]{2,6}$/i(str);
|
|
|
|
|
}
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.pad = function(str, len, pad, pos) {
|
|
|
|
|
// fixme: slighly obscure signature
|
|
|
|
|
// fixme: weird for negative numbers
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.pad(1, 2)
|
|
|
|
|
"01"
|
|
|
|
|
>>> Ox.pad("abc", 6, ".", "right")
|
|
|
|
|
"abc..."
|
|
|
|
|
>>> Ox.pad("foobar", 3, ".", "right")
|
|
|
|
|
"foo"
|
|
|
|
|
>>> Ox.pad("abc", 6, "123456", "right")
|
|
|
|
|
"abc123"
|
|
|
|
|
>>> Ox.pad("abc", 6, "123456", "left")
|
|
|
|
|
"456abc"
|
|
|
|
|
*/
|
|
|
|
|
str = str.toString().substr(0, len);
|
|
|
|
|
pad = Ox.repeat(pad || '0', len - str.length);
|
|
|
|
|
pos = pos || 'left';
|
|
|
|
|
str = pos == 'left' ? pad + str : str + pad;
|
|
|
|
|
str = pos == 'left' ?
|
|
|
|
|
str.substr(str.length - len, str.length) :
|
|
|
|
|
str.substr(0, len);
|
|
|
|
|
return str;
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.repeat = function(obj, num) {
|
|
|
|
|
/*
|
|
|
|
|
works for arrays, numbers and strings
|
|
|
|
|
>>> Ox.repeat(1, 3)
|
|
|
|
|
"111"
|
|
|
|
|
>>> Ox.repeat("foo", 3)
|
|
|
|
|
"foofoofoo"
|
|
|
|
|
>>> Ox.repeat([1, 2], 3)
|
|
|
|
|
[1, 2, 1, 2, 1, 2]
|
|
|
|
|
*/
|
|
|
|
|
var ret;
|
|
|
|
|
if (Ox.isArray(obj)) {
|
|
|
|
|
ret = num >= 1 ? Ox.map(Ox.range(obj.length * num), function(v, i) {
|
|
|
|
|
return obj[i % obj.length]
|
|
|
|
|
}) : [];
|
|
|
|
|
} else {
|
|
|
|
|
ret = num >= 1 ? new Array(num + 1).join(obj.toString()) : '';
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.reverse = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
Ox.reverse("foo")
|
|
|
|
|
oof
|
|
|
|
|
*/
|
|
|
|
|
return str.toString().split('').reverse().join('');
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.startsWith = function(str, sub) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.startsWith("foobar", "foo")
|
|
|
|
|
true
|
|
|
|
|
// fixme:
|
|
|
|
|
// !!(/^sub/(str)) is shorter than
|
|
|
|
|
// Ox.startsWith(str, sub) anyway
|
|
|
|
|
// new RegExp('^' + sub).test(str) is longer though...
|
|
|
|
|
*/
|
|
|
|
|
return new RegExp('^' + sub).test(str);
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.stripTags = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.stripTags("f<span>o</span>o")
|
|
|
|
|
"foo"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/(<.*?>)/gi, '');
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.substr = function(str, start, stop) {
|
|
|
|
|
/***
|
|
|
|
|
Ox.substr behaves like str[start:stop] in Python
|
|
|
|
|
(or like str.substring() with negative values for stop)
|
|
|
|
|
// fixme: needed?
|
|
|
|
|
>>> Ox.substr('foobar', 1)
|
|
|
|
|
"oobar"
|
|
|
|
|
>>> Ox.substr('foobar', -1)
|
|
|
|
|
"r"
|
|
|
|
|
>>> Ox.substr('foobar', 1, 3)
|
|
|
|
|
"oo"
|
|
|
|
|
>>> Ox.substr('foobar', -3, 5)
|
|
|
|
|
"ba"
|
|
|
|
|
>>> Ox.substr('foobar', 1, -2)
|
|
|
|
|
"oob"
|
|
|
|
|
>>> Ox.substr('foobar', -4, -1)
|
|
|
|
|
"oba"
|
|
|
|
|
***/
|
|
|
|
|
stop = Ox.isUndefined(stop) ? str.length : stop;
|
|
|
|
|
return str.substring(
|
|
|
|
|
start < 0 ? str.length + start : start,
|
|
|
|
|
stop < 0 ? str.length + stop : stop
|
|
|
|
|
);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.toCamelCase = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toCamelCase("foo-bar-baz")
|
|
|
|
|
"fooBarBaz"
|
|
|
|
|
>>> Ox.toCamelCase("foo/bar/baz")
|
|
|
|
|
"fooBarBaz"
|
|
|
|
|
>>> Ox.toCamelCase("foo_bar_baz")
|
|
|
|
|
"fooBarBaz"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/[\-_\/][a-z]/g, function(str) {
|
|
|
|
|
return str[1].toUpperCase();
|
|
|
|
|
});
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-05-06 23:30:32 +00:00
|
|
|
|
Ox.toDashes = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toDashes("fooBarBaz")
|
|
|
|
|
"foo-bar-baz"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/[A-Z]/g, function(str) {
|
|
|
|
|
return '-' + str.toLowerCase();
|
|
|
|
|
});
|
|
|
|
|
};
|
2011-04-28 18:34:19 +00:00
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.toSlashes = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toSlashes("fooBarBaz")
|
|
|
|
|
"foo/bar/baz"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/[A-Z]/g, function(str) {
|
|
|
|
|
return '/' + str.toLowerCase();
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.toTitleCase = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toTitleCase("foo")
|
|
|
|
|
"Foo"
|
|
|
|
|
>>> Ox.toTitleCase("Apple releases iPhone, IBM stock plummets")
|
|
|
|
|
"Apple Releases iPhone, IBM Stock Plummets"
|
|
|
|
|
*/
|
|
|
|
|
return Ox.map(str.split(' '), function(v) {
|
|
|
|
|
var sub = v.substr(1),
|
|
|
|
|
low = sub.toLowerCase();
|
|
|
|
|
if (sub == low) {
|
|
|
|
|
v = v.substr(0, 1).toUpperCase() + low;
|
|
|
|
|
}
|
|
|
|
|
return v;
|
|
|
|
|
}).join(" ");
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.toUnderscores = function(str) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.toUnderscores("fooBarBaz")
|
|
|
|
|
"foo_bar_baz"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/[A-Z]/g, function(str) {
|
|
|
|
|
return '_' + str.toLowerCase();
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
2011-04-29 12:40:51 +00:00
|
|
|
|
Ox.trim = function(str) { // is in jQuery, and in JavaScript itself
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
|
|
|
|
Ox.trim(" foo ")
|
|
|
|
|
"foo"
|
|
|
|
|
*/
|
|
|
|
|
return str.replace(/^\s+|\s+$/g, "");
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.truncate = function(str, len, pad, pos) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.truncate("anticonstitutionellement", 16, "...", "center")
|
|
|
|
|
"anticon...lement"
|
|
|
|
|
*/
|
|
|
|
|
var pad = pad || {},
|
|
|
|
|
pos = pos || "right",
|
|
|
|
|
strlen = str.length,
|
|
|
|
|
padlen = pad.length,
|
|
|
|
|
left, right;
|
|
|
|
|
if (strlen > len) {
|
|
|
|
|
if (pos == "left") {
|
|
|
|
|
str = pad + str.substr(padlen + strlen - len);
|
|
|
|
|
} else if (pos == "center") {
|
|
|
|
|
left = Math.ceil((len - padlen) / 2);
|
|
|
|
|
right = Math.floor((len - padlen) / 2);
|
|
|
|
|
str = str.substr(0, left) + pad + str.substr(-right);
|
|
|
|
|
} else if (pos == "right") {
|
|
|
|
|
str = str.substr(0, len - padlen) + pad;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return str;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ox.words = function(str) {
|
|
|
|
|
/*
|
2011-05-05 18:02:56 +00:00
|
|
|
|
> Ox.words("The key/value pairs are read-only--aren't they?")
|
|
|
|
|
["the", "key", "value", "pairs", "are", "read-only", "aren't", "they"]
|
2011-04-27 19:39:56 +00:00
|
|
|
|
*/
|
|
|
|
|
var arr = str.toLowerCase().split(/\b/),
|
|
|
|
|
chr = "-'",
|
|
|
|
|
len = arr.length,
|
|
|
|
|
startsWithWord = !!/\w/(arr[0]);
|
|
|
|
|
arr.forEach(function(v, i) {
|
2011-05-05 18:02:56 +00:00
|
|
|
|
// find single occurrences of "-" or "-"
|
|
|
|
|
// that are not at the beginning or end of the string
|
2011-04-27 19:39:56 +00:00
|
|
|
|
// and join the surrounding words with them
|
|
|
|
|
if (
|
|
|
|
|
i > 0 && i < len - 1 &&
|
|
|
|
|
v.length == 1 && chr.indexOf(v) > -1
|
|
|
|
|
) {
|
|
|
|
|
arr[i + 1] = arr[i - 1] + arr[i] + arr[i + 1];
|
|
|
|
|
arr[i - 1] = arr[i] = '';
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
// remove elements that have been emptied above
|
|
|
|
|
arr = arr.filter(function(v) {
|
|
|
|
|
return v.length;
|
|
|
|
|
});
|
|
|
|
|
// return words, not spaces or punctuation
|
|
|
|
|
return arr.filter(function(v, i) {
|
|
|
|
|
return i % 2 == !startsWithWord;
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.wordwrap <f> Wrap a string at word boundaries
|
|
|
|
|
@*/
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.wordwrap = function(str, len, sep, bal, spa) {
|
2011-04-29 12:40:51 +00:00
|
|
|
|
// fixme: bad API, sep/bal/spa should be in options object
|
2011-04-27 19:39:56 +00:00
|
|
|
|
/*
|
|
|
|
|
>>> Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 25, "<br/>")
|
|
|
|
|
"Anticonstitutionellement, <br/>Paris s'eveille"
|
|
|
|
|
>>> Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 16, "<br/>")
|
|
|
|
|
"Anticonstitution<br/>ellement, Paris <br/>s'eveille"
|
|
|
|
|
>>> Ox.wordwrap("These are short words", 16, "<br/>", true)
|
|
|
|
|
"These are <br/>short words"
|
|
|
|
|
*/
|
|
|
|
|
var str = str === null ? '' : str.toString(),
|
|
|
|
|
len = len || 80,
|
|
|
|
|
sep = sep || "<br/>",
|
|
|
|
|
bal = bal || false,
|
|
|
|
|
spa = Ox.isUndefined(spa) ? true : spa,
|
|
|
|
|
words = str.split(" "),
|
|
|
|
|
lines;
|
|
|
|
|
if (bal) {
|
|
|
|
|
// balance lines: test if same number of lines
|
|
|
|
|
// can be achieved with a shorter line length
|
|
|
|
|
lines = Ox.wordwrap(str, len, sep, false).split(sep);
|
|
|
|
|
if (lines.length > 1) {
|
|
|
|
|
// test shorter line, unless
|
|
|
|
|
// that means cutting a word
|
|
|
|
|
var max = Ox.max(Ox.map(words, function(word) {
|
|
|
|
|
return word.length;
|
|
|
|
|
}));
|
|
|
|
|
while (len > max) {
|
|
|
|
|
len--;
|
|
|
|
|
if (Ox.wordwrap(str, len, sep, false).split(sep).length > lines.length) {
|
|
|
|
|
len++;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
lines = [""];
|
|
|
|
|
Ox.forEach(words, function(word) {
|
|
|
|
|
if ((lines[lines.length - 1] + word + " ").length <= len + 1) {
|
|
|
|
|
// word fits in current line
|
|
|
|
|
lines[lines.length - 1] += word + " ";
|
|
|
|
|
} else {
|
|
|
|
|
if (word.length <= len) {
|
|
|
|
|
// word fits in next line
|
|
|
|
|
lines.push(word + " ");
|
|
|
|
|
} else {
|
|
|
|
|
// word is longer than line
|
|
|
|
|
var chr = len - lines[lines.length - 1].length;
|
|
|
|
|
lines[lines.length - 1] += word.substr(0, chr);
|
|
|
|
|
for (var pos = chr; pos < word.length; pos += len) {
|
|
|
|
|
lines.push(word.substr(pos, len));
|
|
|
|
|
}
|
|
|
|
|
lines[lines.length - 1] += " ";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
if (!spa) {
|
|
|
|
|
lines = Ox.map(lines, function(line) {
|
|
|
|
|
return Ox.trim(line);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
return Ox.trim(lines.join(sep));
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
//@ Type -----------------------------------------------------------------------
|
2011-04-27 19:39:56 +00:00
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isArguments <f> Tests if a value is an arguments "array"
|
|
|
|
|
(value) -> <b> True if the value is an arguments "array"
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isArguments((function() { return arguments; }()))
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isArguments = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return !!(val && val.toString() == '[object Arguments]');
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isArray <f> Tests if a value is an array
|
|
|
|
|
(value) -> <b> True if the value is a date
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isArray([])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isArray((function() { return arguments; }()))
|
|
|
|
|
false
|
|
|
|
|
> Ox.isArray({0: 0, length: 1})
|
|
|
|
|
false
|
|
|
|
|
@*/
|
|
|
|
|
Ox.isArray = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return val instanceof Array;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isBoolean <f> Tests if a value is boolean
|
|
|
|
|
(value) -> <b> True if the value is boolean
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isBoolean(false)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isBoolean = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'boolean';
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isDate <f> Tests if a value is a date
|
|
|
|
|
(value) -> <b> True if the value is a date
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isDate(new Date())
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isDate = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return val instanceof Date;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isElement <f> Tests if a value is a DOM element
|
|
|
|
|
(value) -> <b> True if the value is a DOM element
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isElement(document.createElement())
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isElement = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return !!(val && val.nodeType == 1);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-07 15:56:29 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isEqual <function> Returns true if two values are equal
|
|
|
|
|
> Ox.isEqual(false, false)
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual(0, 0)
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual(NaN, NaN)
|
|
|
|
|
false
|
|
|
|
|
> Ox.isEqual('', '')
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual([1, 2, 3], [1, 2, 3])
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual({a: 1, b: [2, 3], c: {d: '4'}}, {a: 1, b: [2, 3], c: {d: '4'}})
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual({a: 1, b: 2, c: 3}, {c: 3, b: 2, a: 1})
|
|
|
|
|
true // FIXME: is false
|
|
|
|
|
> Ox.isEqual(function(arg) { return arg; }, function(arg) { return arg; })
|
|
|
|
|
true
|
|
|
|
|
> Ox.isEqual(function(foo) { return foo; }, function(bar) { return bar; })
|
|
|
|
|
false
|
|
|
|
|
@*/
|
|
|
|
|
Ox.isEqual = function(obj0, obj1) {
|
|
|
|
|
var ret = false;
|
|
|
|
|
if (obj0 === obj1) {
|
|
|
|
|
ret = true;
|
|
|
|
|
} else if (typeof(obj0) == typeof(obj1)) {
|
|
|
|
|
if (obj0 == obj1) {
|
|
|
|
|
ret = true;
|
|
|
|
|
} else if (Ox.isArray(obj0) && obj0.length == obj1.length) {
|
|
|
|
|
ret = true;
|
|
|
|
|
Ox.forEach(obj0, function(v, i) {
|
|
|
|
|
ret = Ox.isEqual(v, obj1[i]);
|
|
|
|
|
return ret;
|
|
|
|
|
});
|
|
|
|
|
} else if (Ox.isDate(obj0)) {
|
|
|
|
|
ret = obj0.getTime() == obj1.getTime();
|
|
|
|
|
} else if (Ox.isObject(obj0)) {
|
|
|
|
|
ret = Ox.isEqual(Ox.keys(obj0), Ox.keys(obj1)) &&
|
|
|
|
|
Ox.isEqual(Ox.values(obj0), Ox.values(obj1));
|
|
|
|
|
} else if (Ox.isFunction(obj0)) {
|
|
|
|
|
ret = obj0.toString() == obj1.toString();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isFunction <f> Tests if a value is a function
|
|
|
|
|
(value) -> <b> True if the value is a function
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isFunction(function() {})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isFunction(/ /)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isFunction = function(val) { // is in jQuery
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'function' && !Ox.isRegExp(val);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isInfinity <f> Tests if a value is infinite
|
|
|
|
|
(value) -> <b> True if the value is infinite
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isInfinity(Infinity)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isInfinity(-Infinity)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isInfinity(NaN)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isInfinity = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'number' && !isFinite(val) && !Ox.isNaN(val);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isNaN <f> Tests if a value is "Not a Number"
|
|
|
|
|
(value) -> <b> True if the value is "Not a Number"
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isNaN(NaN)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.isNaN = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return val !== val;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isNull <f> Tests if a value is <code>null</code>
|
|
|
|
|
(value) -> <b> True if the value is <code>null</null>
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isNull(null)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
Ox.isNull = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return val === null;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isNumber <f> Tests if a value is a number
|
|
|
|
|
(value) -> <b> True if the value is a number
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isNumber(0)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isNumber(Infinity)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isNumber(-Infinity)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isNumber(NaN)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.isNumber = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'number' && isFinite(val);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isObject <f> Tests if a value is a an object
|
|
|
|
|
(value) -> <b> True if the value is an object
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isObject({})
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isObject([])
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isObject(new Date())
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
> Ox.isObject(null)
|
2011-04-27 19:39:56 +00:00
|
|
|
|
false
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.isObject = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'object' && !Ox.isArguments(val) &&
|
|
|
|
|
!Ox.isArray(val) && !Ox.isDate(val) && !Ox.isNull(val);
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isRegExp <f> Tests if a value is a regular expression
|
|
|
|
|
(value) -> <b> True if the value is a regular expression
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isRegExp(/ /)
|
|
|
|
|
true
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.isRegExp = function(val) {
|
|
|
|
|
/*
|
|
|
|
|
>>> Ox.isRegExp(/ /)
|
|
|
|
|
true
|
|
|
|
|
*/
|
|
|
|
|
return val instanceof RegExp;
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-06 22:47:17 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isString <f> Tests if a value is a string
|
|
|
|
|
(value) -> <b> True if the value is a string
|
|
|
|
|
value <*> Any value
|
|
|
|
|
> Ox.isString('')
|
2011-04-27 19:39:56 +00:00
|
|
|
|
true
|
2011-05-06 22:47:17 +00:00
|
|
|
|
@*/
|
|
|
|
|
|
|
|
|
|
Ox.isString = function(val) {
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'string';
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.isUndefined <f> Tests if a value is undefined
|
2011-05-06 22:47:17 +00:00
|
|
|
|
(value) -> <b> True if the value is undefined
|
|
|
|
|
value <*> Any value
|
2011-05-05 18:02:56 +00:00
|
|
|
|
> Ox.isUndefined()
|
|
|
|
|
true
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.isUndefined = function(val) {
|
2011-05-06 22:47:17 +00:00
|
|
|
|
// fixme: val === void 0 is also nice
|
2011-04-27 19:39:56 +00:00
|
|
|
|
return typeof val == 'undefined';
|
|
|
|
|
};
|
|
|
|
|
|
2011-05-05 18:02:56 +00:00
|
|
|
|
/*@
|
|
|
|
|
Ox.typeOf <f> Returns the type of a value
|
|
|
|
|
(value) -> <s> type
|
|
|
|
|
value <*> Any value
|
|
|
|
|
# Examples
|
|
|
|
|
> (function() { return Ox.typeOf(arguments); }())
|
|
|
|
|
"arguments"
|
|
|
|
|
> Ox.typeOf([])
|
|
|
|
|
"array"
|
|
|
|
|
> Ox.typeOf(false)
|
|
|
|
|
"boolean"
|
|
|
|
|
> Ox.typeOf(new Date())
|
|
|
|
|
"date"
|
|
|
|
|
> Ox.typeOf(document.createElement())
|
|
|
|
|
"element"
|
|
|
|
|
> Ox.typeOf(function() {})
|
|
|
|
|
"function"
|
|
|
|
|
> Ox.typeOf(Infinity)
|
|
|
|
|
"infinity"
|
|
|
|
|
> Ox.typeOf(NaN)
|
|
|
|
|
"nan"
|
|
|
|
|
> Ox.typeOf(null)
|
|
|
|
|
"null"
|
|
|
|
|
> Ox.typeOf(0)
|
|
|
|
|
"number"
|
|
|
|
|
> Ox.typeOf({})
|
|
|
|
|
"object"
|
|
|
|
|
> Ox.typeOf(/ /)
|
|
|
|
|
"regexp"
|
|
|
|
|
> Ox.typeOf('')
|
|
|
|
|
"string"
|
|
|
|
|
> Ox.typeOf()
|
|
|
|
|
"undefined"
|
|
|
|
|
@*/
|
|
|
|
|
|
2011-04-27 19:39:56 +00:00
|
|
|
|
Ox.typeOf = function(val) {
|
|
|
|
|
var ret;
|
|
|
|
|
Ox.forEach(Ox.TYPES, function(type) {
|
|
|
|
|
if (Ox['is' + type](val)) {
|
|
|
|
|
ret = type.toLowerCase();
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return ret;
|
|
|
|
|
};
|