').html(html).html();
// fixme: this converts '"' to '"'
return Ox.element('div').html(html).html();
}
}());
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;
};
}());
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(
'
{host}{end}',
{
end: end,
host: Ox.parseURL(url).hostname,
url: url
}
);
}
);
};
/*
================================================================================
Math functions
================================================================================
*/
Ox.asinh = function(x) {
/*
fixme: no test
*/
return Math.log(x + Math.sqrt(x * x + 1));
};
Ox.deg = function(rad) {
/*
>>> Ox.deg(2 * Math.PI)
360
*/
return rad * 180 / Math.PI;
};
Ox.divideInt = function(num, by) {
/*
>>> Ox.divideInt(100, 3)
[33, 33, 34]
>>> Ox.divideInt(100, 6)
[16, 16, 17, 17, 17, 17]
*/
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;
}
Ox.limit = function(num, min, max) {
/*
>>> Ox.limit(1, 2, 3)
2
>>> Ox.limit(2, 1)
1
*/
var len = arguments.length;
max = arguments[len - 1];
min = len == 3 ? min : 0;
return Math.min(Math.max(num, min), max);
};
Ox.log = function(num, base) {
/*
>>> Ox.log(100, 10)
2
>>> Ox.log(Math.E)
1
*/
return Math.log(num) / Math.log(base || Math.E);
};
Ox.mod = function(num, by) {
/*
>>> Ox.mod(11, 10)
1
>>> Ox.mod(-11, 10)
9
*/
var mod = num % by;
return mod >= 0 ? mod : mod + by;
};
Ox.rad = function(deg) {
/*
>>> Ox.rad(360)
2 * Math.PI
*/
return deg * Math.PI / 180;
};
Ox.random = function() {
/*
>>> Ox.random(3) in {0: 0, 1: 0, 2: 0, 3: 0}
true
>>> Ox.random(1, 2) in {1: 0, 2: 0}
true
*/
var len = arguments.length,
min = len == 1 ? 0 : arguments[0],
max = arguments[len - 1];
return min + parseInt(Math.random() * (max - min + 1));
};
Ox.round = function(num, dec) {
/*
>>> Ox.round(2 / 3, 6)
0.666667
>>> Ox.round(1 / 2, 3)
0.5
*/
var pow = Math.pow(10, dec || 0);
return Math.round(num * pow) / pow;
};
Ox.sinh = function(x) {
/*
fixme: no test
*/
return (Math.exp(x) - Math.exp(-x)) / 2;
};
Ox.MAX_LATITUDE = Ox.deg(Math.atan(Ox.sinh(Math.PI)));
Ox.MIN_LATITUDE = -Ox.MAX_LATITUDE;
/*
================================================================================
RegExp functions
================================================================================
*/
Ox.regexp = {
'accents': '¨´`ˆ˜',
'letters': 'a-z¨´`ˆ˜äåáàâãæçëéèèñïíìîöóòôõøœßúùûÿ'
};
/*
================================================================================
String functions
================================================================================
*/
Ox.basename = function(str) {
/*
fixme: this should go into Path functions
>>> Ox.basename("foo/bar/foo.bar")
"foo.bar"
>>> Ox.basename("foo.bar")
"foo.bar"
*/
return str.replace(/^.*[\/\\]/g, '');
};
Ox.char = String.fromCharCode;
Ox.clean = function(str) {
/*
>>> Ox.clean("foo bar")
"foo bar"
>>> Ox.clean(" foo bar ")
"foo bar"
>>> Ox.clean(" foo \n bar ")
"foo\nbar"
*/
return Ox.map(str.split('\n'), function(str) {
return Ox.trim(str.replace(/\s+/g, ' '));
}).join('\n');
};
Ox.contains = function(str, chr) {
/*
>>> Ox.contains("foo", "bar")
false
>>> Ox.contains("foobar", "bar")
true
*/
return str.indexOf(chr) > -1;
};
Ox.endsWith = function(str, sub) {
/*
>>> Ox.endsWith("foobar", "bar")
true
*/
return str.toString().substr(-sub.length) === sub;
};
Ox.highlight = function(txt, str) {
// fixme: move to ox.ui
return str ? txt.replace(
new RegExp('(' + str + ')', 'ig'),
'
$1'
) : txt;
};
Ox.isValidEmail = function(str) {
/*
>>> Ox.isValidEmail("foo@bar.com")
true
>>> Ox.isValidEmail("foo.bar@foobar.co.uk")
true
>>> Ox.isValidEmail("foo@bar")
false
*/
return !!/^[0-9A-Z\.\+\-_]+@(?:[0-9A-Z\-]+\.)+[A-Z]{2,6}$/i(str);
}
Ox.pad = function(str, len, pad, pos) {
/*
>>> 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;
};
Ox.repeat = function(str, num) {
/*
>>> Ox.repeat(1, 3)
"111"
>>> Ox.repeat("foo", 3)
"foofoofoo"
*/
return num >= 1 ? new Array(num + 1).join(str.toString()) : '';
};
Ox.reverse = function(str) {
/*
Ox.reverse("foo")
oof
*/
return str.toString().split('').reverse().join('');
};
Ox.startsWith = function(str, sub) {
/*
>>> Ox.startsWith("foobar", "foo")
true
*/
return str.toString().substr(0, sub.length) === sub;
};
Ox.stripTags = function(str) {
/*
>>> Ox.stripTags("f
oo")
"foo"
*/
return str.replace(/(<.*?>)/gi, '');
};
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();
});
};
Ox.toDashes = function(str) {
/*
>>> Ox.toDashes("fooBarBaz")
"foo-bar-baz"
*/
return str.replace(/[A-Z]/g, function(str) {
return '-' + str.toLowerCase();
});
};
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();
});
};
Ox.trim = function(str) { // is in jQuery
/*
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) {
/*
>>> Ox.words('He\'s referring to the "ill-conceived" AOL/TimeWarner merger--didn\'t you know?')
['he\'s', 'referring', 'to' , 'the' , 'ill-conceived' , 'aol', 'timewarner' , 'merger' , 'didn\'t', 'you', 'know']
*/
var arr = str.toLowerCase().split(/\b/),
chr = "-'",
len = arr.length,
startsWithWord = !!/\w/(arr[0]);
arr.forEach(function(v, i) {
// find single occurrences of chars in chr
// that are not at the beginning or end of str
// 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;
});
}
Ox.wordwrap = function(str, len, sep, bal, spa) {
/*
>>> Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 25, "
")
"Anticonstitutionellement,
Paris s'eveille"
>>> Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 16, "
")
"Anticonstitution
ellement, Paris
s'eveille"
>>> Ox.wordwrap("These are short words", 16, "
", true)
"These are
short words"
*/
var str = str === null ? '' : str.toString(),
len = len || 80,
sep = sep || "
",
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));
};
/*
================================================================================
Type functions
================================================================================
*/
Ox.isArguments = function(val) {
/*
>>> Ox.isArguments((function() { return arguments; }()))
true
*/
return !!(val && val.toString() == '[object Arguments]');
}
Ox.isArray = function(val) { // is in jQuery
/*
>>> Ox.isArray([])
true
*/
return val instanceof Array;
}
Ox.isBoolean = function(val) {
/*
>>> Ox.isBoolean(false)
true
*/
return typeof val == 'boolean';
};
Ox.isDate = function(val) {
/*
>>> Ox.isDate(new Date())
true
*/
return val instanceof Date;
};
Ox.isElement = function(val) {
/*
>>> Ox.isElement(document.createElement())
true
*/
return !!(val && val.nodeType == 1);
};
Ox.isFunction = function(val) { // is in jQuery
/*
>>> Ox.isFunction(function() {})
true
>>> Ox.isFunction(/ /)
false
*/
return typeof val == 'function' && !Ox.isRegExp(val);
};
Ox.isInfinity = function(val) {
/*
>>> Ox.isInfinity(Infinity)
true
>>> Ox.isInfinity(-Infinity)
true
>>> Ox.isInfinity(NaN)
false
*/
return typeof val == 'number' && !isFinite(val) && !Ox.isNaN(val);
};
Ox.isNaN = function(val) {
/*
>>> Ox.isNaN(NaN)
true
*/
return val !== val;
}
Ox.isNull = function(val) {
/*
>>> Ox.isNull(null)
true
*/
return val === null;
};
Ox.isNumber = function(val) {
/*
>>> Ox.isNumber(0)
true
>>> Ox.isNumber(Infinity)
false
>>> Ox.isNumber(-Infinity)
false
>>> Ox.isNumber(NaN)
false
*/
return typeof val == 'number' && isFinite(val);
};
Ox.isObject = function(val) {
/*
>>> Ox.isObject({})
true
>>> Ox.isObject([])
false
>>> Ox.isObject(new Date())
false
>>> Ox.isObject(null)
false
*/
return typeof val == 'object' && !Ox.isArguments(val) &&
!Ox.isArray(val) && !Ox.isDate(val) && !Ox.isNull(val);
};
Ox.isRegExp = function(val) {
/*
>>> Ox.isRegExp(/ /)
true
*/
return val instanceof RegExp;
};
Ox.isString = function(val) {
/*
>>> Ox.isString('')
true
*/
return typeof val == 'string';
};
Ox.isUndefined = function(val) {
/*
>>> Ox.isUndefined()
true
*/
return typeof val == 'undefined';
};
Ox.typeOf = function(val) {
/*
>>> (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'
*/
var ret;
Ox.forEach(Ox.TYPES, function(type) {
if (Ox['is' + type](val)) {
ret = type.toLowerCase();
return false;
}
});
return ret;
};