Enabling iterators on ObjectLikeSequence.keys and *.values

gistfile1.md

##Code

//--------------------//
// ObjectLikeSequence //
//--------------------//

Lazy.ObjectLikeSequence.prototype.keys = function keys() {
    return new KeySequence(this);
};

Lazy.ObjectLikeSequence.prototype.values = function values() {
    return new ValueSequence(this);
};


//-------------//
// KeySequence //
//-------------//

function KeySequence(parent) {
    this.parent = parent;
}

KeySequence.prototype = new Lazy.ObjectLikeSequence();

KeySequence.prototype.each = function each(fn) {
    return this.parent.each(function(v, k) {
        return fn(k);
    });
};

KeySequence.prototype.toArray = function toArray() {
    return this.reduce(function(arr, element) {
        arr.push(element);
        return arr;
    }, []);
};

KeySequence.prototype.getIterator = function getIterator() {
    return new KeyIterator(this.parent);
};

function KeyIterator(sequence) {
    this.iterator = sequence.getIterator();
    this.index = -1;
}

KeyIterator.prototype.current = function current() {
    return this.iterator.current()[0];
};

KeyIterator.prototype.moveNext = function moveNext() {
    return this.iterator.moveNext();
};


//---------------//
// ValueSequence //
//---------------//

function ValueSequence(parent) {
    this.parent = parent;
}

ValueSequence.prototype = new Lazy.ObjectLikeSequence();

ValueSequence.prototype.getIterator = function getIterator() {
    return new ValueIterator(this.parent);
};

ValueSequence.prototype.each = function each(fn) {
    return this.parent.each(function(v, k) {
        return fn(v);
    });
};

ValueSequence.prototype.toArray = function toArray() {
    return this.reduce(function(arr, element) {
        arr.push(element);
        return arr;
    }, []);
};

function ValueIterator(sequence) {
    this.iterator = sequence.getIterator();
    this.index = -1;
}

ValueIterator.prototype.current = function current() {
    return this.iterator.current()[1];
};

ValueIterator.prototype.moveNext = function moveNext() {
    return this.iterator.moveNext();
};

##Mocha Tests

var chai = require('chai');

var assert = chai.assert;
chai.config.includeStack = true;

var objLit
	, objLitConst;

function getNewObjLit() {
	return {
		'akey': 'aval'
		, 'bkey': 'bval'
		, 'ckey': 'cval'
	};
}

setup(function() {
	objLit = Lazy(getNewObjLit());
	objLitConst = Lazy(getNewObjLit());
});

test("ObjectLikeSequence.keys", function ObjectLikeSequence_keys() {
	assert.isTrue(objLit.keys().equals(objLitConst.keys()));
	objLit = objLit.assign({
		'dkey': 'dval'
	});
	assert.isFalse(objLit.keys().equals(objLitConst.keys()));
});

test("ObjectLikeSequence.values", function ObjectLikeSequence_keys() {
	assert.isTrue(objLit.values().equals(objLitConst.values()));
	objLit = objLit.assign({
		'dkey': 'dval'
	});
	assert.isFalse(objLit.values().equals(objLitConst.values()));
});

test("KeySequence.toArray", function KeySequence_toArray() {
	var keyArray = objLitConst.keys().toArray();
	var expectedKeyArray = Object.keys(getNewObjLit());

	assert.strictEqual(keyArray[0], expectedKeyArray[0]);
	assert.strictEqual(keyArray[2], expectedKeyArray[2]);
});

test("KeySequence.each", function KeySequence_each() {
	var keyArray = objLitConst.keys().toArray();
	var i = 0;
	objLit.keys().each(function(k) {
		assert.strictEqual(k, keyArray[i]);
		i += 1;
	});
});

test("KeyIterator.current && moveNext", function KeyIterator_current_moveNext() {
	var keyArray = objLitConst.keys().toArray();
	var kit = objLit.keys().getIterator();
	var i = 0;
	while (kit.moveNext()) {
		assert.strictEqual(kit.current(), keyArray[i]);
		i += 1;
	}
});

test("ValueSequence.toArray", function ValueSequence_toArray() {
	var valArray = objLitConst.values().toArray();
	var tmpObj = getNewObjLit();
	var expectedValArray = Object.keys(tmpObj).reduce(function(aggr, k) {
		aggr.push(tmpObj[k])
		return aggr;
	}, []);

	assert.strictEqual(valArray[0], expectedValArray[0]);
	assert.strictEqual(valArray[2], expectedValArray[2]);
});

test("ValueSequence.each", function KeySequence_each() {
	var valArray = objLitConst.values().toArray();
	var i = 0;
	objLit.values().each(function(v) {
		assert.strictEqual(v, valArray[i]);
		i += 1;
	});
});

test("ValueIterator.current && moveNext", function KeyIterator_current_moveNext() {
	var valArray = objLitConst.values().toArray();
	var vit = objLit.values().getIterator();
	var i = 0;
	while (vit.moveNext()) {
		assert.strictEqual(vit.current(), valArray[i]);
		i += 1;
	}
});