javascript/ruby.js
/*
** ruby.js -- Ruby-style object extensions for JavaScript
** Copyright (c) 2006 Florian Gross <flgr@ccan.de>
** Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com>
** Licensed under GPL <http://www.gnu.org/licenses/gpl.txt>
**
** This is derived from the Florian Gross' "ruby.js", version 0.4.0 as
** of 2005-09-05 from http://flgr.0x42.net/ruby.js/, which implements
** some of Ruby's standard library functions in JavaScript. It was
** reformatted and cleaned up (especially semicolons additions to allow
** code packing) by Ralf S. Engelschall.
**
** $LastChangedDate: $
** $LastChangedRevision: $
*/
/*
* Notice: This library heavily touches the global JavaScript namespace
* and actually doesn't create a custom namespace at all. It is
* expected that this library will become obsolete when the next
* revision of the ECMA-262 standard is released as there is plans to
* offer more functionality as part of the official language's standard
* library. Note that this implementation does not exactly mimic all
* of Ruby's standard library -- ".each" in general always yields
* value,key where key is the index for sequential containers and the
* Range implementation is known to have bugs.
*/
(function(){
/*
* "Object" extensions
*/
Object.prototype.clone = function (deepClone) {
var result = new this.constructor();
for (var property in this) {
if (deepClone && typeof this[property] === 'object')
result[property] = this[property].clone(deepClone);
else
result[property] = this[property];
}
return result;
};
Object.prototype.extend = function (other) {
if (!this.mixins)
this.mixins = [];
this.mixins.push(other);
for (var property in other)
if (!this.hasOwnProperty(property))
this[property] = other[property];
return;
};
Object.prototype.cmp = function (other) {
if (this < other)
return -1;
if (this > other)
return +1;
return 0;
};
Object.prototype.valuesAt = function () {
var obj = this;
return(arguments.toArray().map(function(index) {
return obj[index];
}));
};
Object.prototype.toArray = function () {
if (!this.length)
throw "Can't convert";
var result = [];
for (var i = 0; i < this.length; i++)
result.push(this[i]);
return result;
};
Object.prototype.hash = function () {
return this.toSource().hash();
};
Object.prototype.instanceOf = function (klass) {
return (this.constructor == klass);
};
Object.prototype.isA =
Object.prototype.kindOf = function (klass) {
if (this.instanceOf(klass))
return true;
if (this["mixins"] != undefined && this.mixins.includes(klass))
return true;
return false;
};
Object.prototype.methods = function () {
var result = [];
for (var property in this)
if (typeof this[property] === "function")
result.push(property);
return result;
};
Object.prototype.respondTo = function (method) {
return this.methods().includes(method);
};
Object.prototype.send = function(method) {
var rest = arguments.toArray().last(-1);
if (!this.respondTo(method))
throw "undefined method";
return this[method].apply(this, rest);
};
Object.prototype.instanceEval = function (code) {
if (code.isA(Function))
return code.apply(this);
return eval(code.toString());
};
/*
* "Number" extensions
*/
Number.prototype.times = function (block) {
for (var i = 0; i < this; i++)
block(i);
};
Number.prototype.upto = function (other, block) {
for (var i = this; i <= other; i++)
block(i);
};
Number.prototype.downto = function (other, block) {
for (var i = this; i >= other; i--)
block(i);
};
Number.prototype.towards = function (other, block) {
var step = this.cmp(other);
for (var i = this; i !== other - step; i -= step)
block(i);
};
Number.prototype.succ = function () {
return this + 1;
};
Number.prototype.pred = function () {
return this - 1;
};
Number.prototype.chr = function () {
return String.fromCharCode(this);
};
/*
* "Enumerable" addition
*/
var Enumerable = new Object();
Enumerable.eachWindow = function (window, block) {
if (!window.isA(Range))
window = range(0, window);
var elements = [], pushed = 0;
this.each(function (item, index) {
elements.push(item);
pushed += 1;
if (pushed % window.rend == 0) {
var start = [0, window.start - window.rend + pushed].max();
var end = [0, window.rend + pushed].max();
block(elements.fetch(xrange(start, end)), index);
}
});
};
Enumerable.collect =
Enumerable.map = function (block) {
var result = [];
this.each(function (item, index) {
result.push(block(item, index));
});
return result;
};
Enumerable.toArray = Enumerable.entries = function () {
return this.map(function (item) {
return(item);
});
};
Enumerable.inject = function (firstArg) {
var state, block, first = true;
if (arguments.length == 1)
block = firstArg;
else {
state = firstArg;
block = arguments[1];
}
this.each(function (item, index) {
if (first && typeof state === "undefined")
state = item, first = false;
else
state = block(state, item, index);
});
return state;
};
Enumerable.find =
Enumerable.detect = function (block) {
var result, done;
this.each(function (item, index) {
if (!done && block(item, index)) {
result = item;
done = true;
}
});
return result;
};
Enumerable.findAll =
Enumerable.select = function (block) {
return this.inject([], function (result, item, index) {
return (block(item, index) ? result.add(item) : result);
});
};
Enumerable.grep = function (obj) {
return this.findAll(function (item) {
return obj.test(item);
});
};
Enumerable.reject = function (block) {
return this.select(function (item, index) {
return !block(item, index);
});
};
Enumerable.compact = function () {
return this.select(function (item) {
return (typeof item !== "undefined")
});
};
Enumerable.nitems = function () {
return this.compact().length;
};
Enumerable.sortBy = function (block) {
return this.map(function(item, index) {
return [ block(item, index), item ];
}).sort(function (a, b) {
return a[0].cmp(b[0]);
}).map(function (item) {
return item[1];
});
};
Enumerable.all = function (block) {
return (this.findAll(block).length == this.length);
};
Enumerable.any = function (block) {
return (typeof this.find(block) !== "undefined");
};
Enumerable.includes = function (obj) {
return this.any(function (item) {
return (item === obj);
});
};
Enumerable.index = function (obj) {
var result;
this.find(function (item, index) {
if (obj == item) {
result = index;
return true;
} else
return false;
});
return result;
};
Enumerable.uniq = function () {
return this.inject([], function (result, item) {
return (result.includes(item) ? result : result.add(item));
});
};
Enumerable.max = function (block) {
if (!block)
block = function (a, b) { return a.cmp(b); };
return this.sort(block).last();
};
Enumerable.min = function (block) {
if (!block) {
block = function (a, b) { return a.cmp(b); };
return this.sort(block).first();
};
Enumerable.partition = function (block) {
var positives = [], negatives = [];
this.each(function (item, index) {
if (block(item, index))
positives.push(item);
else
negatives.push(item);
});
return [positives, negatives];
};
Enumerable.zip = function () {
var ary = arguments.toArray();
ary.unshift(this);
return ary.transpose();
};
Enumerable.flatten = function (depth) {
if (depth == undefined)
depth = -1;
if (!depth)
return this;
return this.inject([], function(result, item) {
var flatItem = item.respondTo("flatten") ? item.flatten(depth - 1) : [item];
return result.merge(flatItem);
});
};
/*
* "Array" extension
*/
Array.fromObject = function (obj) {
if (!obj.length)
throw "Can't convert";
var result = [];
for (var i = 0; i < obj.length; i++)
result.push(obj[i]);
return result;
};
Array.prototype.transpose = function () {
var result, length = -1;
this.each(function (item, index) {
if (length < 0) { /* first element */
length = item.length;
result = Array.withLength(length, function () {
return new Array(this.length);
});
} else if (length != item.length) {
throw "Element sizes differ";
}
item.each(function (iitem, iindex) {
result[iindex][index] = iitem;
});
});
return result;
};
Array.withLength = function (length, fallback) {
var result = [null].mul(length);
result.fill(fallback);
return result;
};
Array.prototype.each = function (block) {
for (var index = 0; index < this.length; index++) {
var item = this[index];
block(item, index);
}
return this;
};
Array.prototype.extend(Enumerable);
Array.prototype.isEmpty = function () {
return (this.length == 0);
};
Array.prototype.at =
Array.prototype.fetch = function (index, length) {
if (index.isA(Range)) {
var end = index.rend + (index.rend < 0 ? this.length : 0);
index = index.start;
length = end - index + 1;
}
if (length == undefined)
length = 1;
if (index < 0)
index += this.length;
var result = this.slice(index, index + length);
return (result.length == 1 ? result[0] : result);
};
Array.prototype.first = function (amount) {
if (amount == undefined)
amount = 1;
return this.at(xrange(0, amount));
};
Array.prototype.last = function (amount) {
if (amount == undefined)
amount = 1;
return this.at(range(-amount, -1));
};
Array.prototype.store = function (index) {
var length = 1, obj;
arguments = arguments.toArray();
arguments.shift();
if (arguments.length == 2)
length = arguments.shift();
obj = arguments.shift();
if (!obj.isA(Array))
obj = [obj];
if (index.isA(Range)) {
var end = index.rend + (index.rend < 0 ? this.length : 0);
index = index.start;
length = end - index + 1;
}
if (index < 0)
index += this.length;
this.replace(this.slice(0, index).merge(obj).merge(this.slice(index + length)));
return this;
};
Array.prototype.insert = function (index) {
var values = arguments.toArray().last(-1);
if (index < 0)
index += this.length + 1;
return this.store(index, 0, values);
};
Array.prototype.update = function (other) {
var obj = this;
other.each(function(item) { obj.push(item) });
return obj;
};
Array.prototype.merge = Array.prototype.concat;
Array.prototype.add = function (item) {
return this.merge([item]);
};
Array.prototype.clear = function () {
var obj = this;
this.length.times(function (index) {
delete obj[index];
});
this.length = 0;
};
Array.prototype.replace = function (obj) {
this.clear();
this.update(obj);
};
Array.prototype.mul = function (count) {
var result = [];
var obj = this;
count.times(function() {
result = result.merge(obj);
});
return result;
};
Array.prototype.fill = function (value) {
var old_length = this.length;
var obj = this;
this.clear();
var block;
if (typeof value !== "function")
block = function() { return(value) };
else
block = value;
old_length.times(function (i) {
obj.push(block(i));
});
};
Array.prototype.removeAt = function (targetIndex) {
var result = this[targetIndex];
var newArray = this.reject(function (item, index) {
return (index == targetIndex);
});
this.replace(newArray);
return result;
};
Array.prototype.remove = function (obj) {
this.removeAt(this.index(obj));
};
Array.prototype.removeIf = function (block) {
this.replace(this.reject(block));
};
/*
* "Range" addition
*/
function Range (start, end, excludeEnd) {
this.begin = this.start = start;
this.end = end;
this.excludeEnd = excludeEnd;
this.rend = excludeEnd ? end.pred() : end;
this.length = this.toArray().length;
};
function range (start, end) {
return (new Range(start, end));
}
function xrange(start, end) {
return (new Range(start, end, true));
}
Range.prototype.toString = function () {
return ("" + this.start + (this.excludeEnd ? "..." : "..") + this.end);
}
Range.prototype.each = function (block) {
var index = 0;
this.start.towards(this.rend, function (i) {
return block(i, index++);
});
}
Range.prototype.extend(Enumerable);
Range.prototype.includes = function (item) {
return (this.start.cmp(item) == -1 && this.rend.cmp(item) == +1);
};
/*
* "Hash" addition
*/
function Hash (defaultBlock) {
this.defaultBlock = defaultBlock;
this.keys = [];
this.values = [];
this.length = 0;
}
Hash.fromArray = function (array) {
var result = new Hash();
array.each(function (item) {
var key = item[0], value = item[1];
result.store(key, value);
});
return result;
};
Hash.prototype.at =
Hash.prototype.fetch = function (key, block) {
if (this.hasKey(key))
return this["item_" + key.hash()];
else if (block)
return block(key);
else
return defaultBlock(key);
};
Hash.prototype.store = function (key, value) {
this.keys.push(key);
this.values.push(value);
this.length++;
return (this["item_" + key.hash()] = value);
};
Hash.prototype.toA = function () {
return this.keys.zip(this.values);
};
Hash.prototype.isEmpty = function () {
return (this.length == 0);
};
Hash.prototype.has =
Hash.prototype.includes =
Hash.prototype.hasKey = function (key) {
return hasOwnProperty("item_" + key.hash());
};
Hash.prototype.hasValue = function (value) {
return this.values.includes(value);
};
Hash.prototype.each = function (block) {
this.toA().each(function (pair) {
return block(pair[1], pair[0]);
});
};
Hash.prototype.extend(Enumerable);
Hash.prototype.merge = function (other) {
other.each(function (value, key) {
this.store(key, value);
});
};
Hash.prototype.remove = function (key) {
var valueIndex = this.keys.index(key);
var value = this.values[valueIndex];
this.keys.remove(key);
this.values.removeAt(valueIndex);
delete(this["item_" + key.hash()]);
this.length--;
return [key, value];
};
Hash.prototype.removeIf = function (block) {
this.each(function (value, key) {
if (block(value, key))
this.remove(key);
});
};
Hash.prototype.shift = function () {
return this.remove(this.keys[0]);
};
Hash.prototype.clear = function () {
var obj = this;
this.length.times(function() {obj.shift()});
};
Hash.prototype.replace = function (obj) {
this.clear();
this.merge(obj);
};
Hash.prototype.invert = function () {
return Hash.fromArray(this.map(function (value, key) {
return [value, key];
}));
};
Hash.prototype.rehash = function () {
var result = new Hash(this.defaultBlock);
this.each(function (value, key) {
result.store(key, value);
});
this.replace(result);
};
/*
* "MatchData" addition
*/
function MatchData (matches, str, pos) {
this.matches = matches, this.string = str;
this.begin = this.position = pos;
this.match = matches[0];
this.captures = matches.slice(1);
this.end = pos + this.match.length;
this.length = matches.length;
this.preMatch = str.substr(0, pos);
this.postMatch = str.substr(this.end);
}
MatchData.prototype.toString = function () {
return this.match;
};
MatchData.prototype.at = function (index) {
return this.matches.at(index);
};
MatchData.prototype.toArray = function () {
return this.matches;
};
/*
* "RegExp" extension
*/
RegExp.prototype.match = function (str) {
var matches = this.exec(str);
if (matches) {
var pos = str.search(this);
return (new MatchData(matches, str, pos));
}
};
/*
* "String" extension
*/
String.prototype.clone = function () {
return (new String(this));
};
String.prototype.each = function (block) {
this.split("\n").each(block);
};
String.prototype.extend(Enumerable);
String.prototype.toArray = function () {
return this.split("\n");
};
String.prototype.towards = function (other, block) {
var item = this;
while (item.cmp(other) <= 0) {
block(item);
item = item.succ();
}
};
String.prototype.hash = function () {
var result = 0;
this.split("").each(function (item) {
result += item.charCodeAt(0);
result += (result << 10);
result ^= (result >> 6);
})
result += (result << 3);
result ^= (result >> 11);
result += (result << 15);
return result;
}
String.prototype.chars = function () {
return this.split("");
};
String.prototype.at =
String.prototype.fetch = function (index, length) {
if (index.isA(Range)) {
var end = index.rend + (index.rend < 0 ? this.length : 0);
index = index.start;
length = end - index + 1;
}
if (length == undefined)
length = 1;
if (index < 0)
index += this.length;
return this.substr(index, length);
};
String.prototype.store =
String.prototype.change = function (index) {
var length = 1, obj;
arguments = arguments.toArray();
arguments.shift();
if (arguments.length == 2)
length = arguments.shift();
obj = arguments.shift();
if (index.isA(Range)) {
var end = index.rend + (index.rend < 0 ? this.length : 0);
index = index.start;
length = end - index + 1;
}
if (index < 0)
index += this.length;
return (this.substr(0, index) + obj + this.substr(index + length));
};
String.prototype.reverse = function () {
return this.split("").reverse().join("");
};
String.prototype.scan = function (pattern) {
var str = this, result = [], oldPos = -1, match, offset = 0;
while (match = pattern.match(str)) {
if (match.end == match.begin)
throw "Can't have null length matches with scan()";
var newMatch = new MatchData(match.matches, match.string, match.position + offset);
result.push(newMatch);
str = match.postMatch;
offset += match.toString().length;
}
return result;
};
String.prototype.sub = function (what, by, global) {
var block = (typeof by === "function" ? by : function() { return(by) });
var matches = this.scan(what), result = this, offset = 0;
if (!global && !by.global)
matches = matches.slice(0, 1);
matches.each(function (match) {
var replacement = block(match);
offset += replacement.length - match.toString().length;
result = result.change(match.begin + offset, match.toString().length, replacement);
});
return result;
};
String.prototype.gsub = function (what, by) {
return this.sub(what, by, true);
};
String.prototype.tr = function (from, to) {
var map = Hash.fromArray(from.chars().zip(to.chars()));
return (this.chars().map(function (chr) {
return (map.includes(chr) ? map.fetch(chr) : chr);
}).join(""));
};
String.prototype.mul = function (other) {
var result = "", str = this;
other.times(function() {
result += str;
});
return result;
};
String.prototype.isUpcase = function () {
return (this == this.upcase());
};
String.prototype.isDowncase = function () {
return (this == this.downcase());
}
String.prototype.isCapitalized = function () {
return ( this.fetch(0).isUpcase()
&& this.fetch(range(1, -1)).isDowncase());
};
String.prototype.upcase = String.prototype.toUpperCase;
String.prototype.downcase = String.prototype.toLowerCase;
String.prototype.capitalize = function () {
return (this.fetch(0).upcase() + this.fetch(range(1, -1)).downcase());
};
String.prototype.swapcase = function () {
return (this.chars().map(function (chr) {
if (chr.isUpcase())
return chr.downcase();
if (chr.isDowncase())
return chr.upcase();
return chr;
}).join(""));
};
String.prototype.ord = function () {
return this.charCodeAt(0);
};
String.prototype.isEmpty = function () {
return (this.length == 0);
}
String.prototype.succ = function () {
if (this.isEmpty())
return this;
/* numerics */
if (/^\d+$/.test(this))
return ((Number(this) + 1).toString());
/* just one character */
if (this.length == 1) {
/* letters */
if (/[A-Za-z]/.test(this)) {
var lastLetter = this.isUpcase() ? 'Z' : 'z';
var firstLetter = this.isUpcase() ? 'A' : 'a';
return ((this == lastLetter) ? firstLetter.mul(2) : (this.ord() + 1).chr());
}
return (this == (-1).chr() ? 0.0.chr().mul(2) : (this.ord() + 1).chr());
}
/* multiple characters */
var result = this;
for (var index = this.length; --index >= 0; ) {
var chr = this.at(index);
if (chr.succ().length == 1 || index == 0)
return result.change(index, chr.succ());
result = result.change(index, chr.succ().at(-1));
}
return result;
};
String.prototype.ljust = function (length, fill) {
if (!fill)
fill = " ";
if (fill.length > 1)
throw "TODO: Make fills with length > 1 work.";
return (this + fill.mul(length / fill.length - this.length));
};
})();
![Ralf S. Engelschall's Train of Thoughts [.org]](/repo/theme/tot-img/tot-2-CUT-typo-T.png)