@@ -71,7 +71,7 @@ You should have a look at the "documentation":http://njonsson.github.com/rouge. h1. Test coverage -Rouge has around 400 executable specifications authored using the "Screw.Unit":http://github.com/nathansobo/screw-unit framework. Run the specs by opening _src/spec/suite.html_. (Firefox works best for this.) +Rouge has around 500 executable specifications authored using the "Screw.Unit":http://github.com/nathansobo/screw-unit framework. Run the specs by opening _src/spec/suite.html_. (Firefox works best for this.) h1. Credits README.textile @@ -92,6 +92,36 @@ Array['new'] = function() { }; /** + * An alias for #areAll. + * + * @param {Function} block (optional) The function to execute. Should have one + * parameter + * @returns {Boolean} <tt>true</tt> if block</t> does not return + * <tt>false</tt> or <tt>null</tt> for any element + * + * @see #areAll #areAll + * @see #any? #any? + */ +Array.prototype['all?'] = function(block) { + return this.areAll.apply(this, arguments); +}; + +/** + * An alias for #areAny. + * + * @param {Function} block (optional) The function to execute. Should have one + * parameter + * @returns {Boolean} <tt>true</tt> if block</t> returns a value other than + * <tt>false</tt> or <tt>null</tt> for any element + * + * @see #areAny #areAny + * @see #all? #all? + */ +Array.prototype['any?'] = function(block) { + return this.areAny.apply(this, arguments); +}; + +/** * Passes each element in the array to block, returning <tt>true</tt> if * block never returns <tt>false</tt> or <tt>null</tt>. If block * is not given, Rouge adds an implicit block that will return <tt>true</tt> @@ -211,7 +241,8 @@ Array.prototype.areAny = function(block) { * @param {Function} block The function to execute. Should have one parameter * @returns {Array} An array containing the values returned by block * - * @see #map #map + * @see #collectThis #collectThis + * @see #map #map */ Array.prototype.collect = function(block) { var result = []; @@ -237,6 +268,7 @@ Array.prototype.collect = function(block) { * @param {Function} block The function to execute. Should have one parameter * @returns {Array} The array * + * @see #collect #collect * @see #mapThis #mapThis */ Array.prototype.collectThis = function(block) { @@ -247,6 +279,19 @@ Array.prototype.collectThis = function(block) { }; /** + * An alias for #collectThis. + * + * @param {Function} block The function to execute. Should have one parameter + * @returns {Array} The array + * + * @see #collectThis #collectThis + * @see #collect #collect + */ +Array.prototype['collect!'] = function(block) { + return this.collectThis.apply(this, arguments); +}; + +/** * Finds an element in the array. Invokes block once for each element in * the array, passing that element as an argument. * @@ -281,7 +326,8 @@ Array.prototype.collectThis = function(block) { * If block never returns <tt>true</tt> and ifNone is not * specified, then <tt>null</tt> is used * - * @see #find #find + * @see #find #find + * @see #select #select */ Array.prototype.detect = function(ifNone, block) { function detectOrNone(ifNone, block) { @@ -606,6 +652,19 @@ Array.prototype.hasMember = function(value) { }; /** + * An alias for #doesInclude. + * + * @param {Object} value A value to look for + * @returns {Boolean} <tt>true</tt> if value</t> is an element + * + * @see #doesInclude #doesInclude + * @see #member? #member? + */ +Array.prototype['include?'] = function(block) { + return this.doesInclude.apply(this, arguments); +}; + +/** * Combines the elements of the array by applying block to an accumulator * value (memo) and each element in turn. Invokes block once for * each element in the array, passing memo and that element as arguments. @@ -665,6 +724,7 @@ Array.prototype.inject = function(initial, block) { * @returns {Array} An array containing the values returned by block * * @see #collect #collect + * @see #mapThis #mapThis */ Array.prototype.map = function(block) { return this.collect.apply(this, arguments); @@ -677,12 +737,39 @@ Array.prototype.map = function(block) { * @returns {Array} The array * * @see #collectThis #collectThis + * @see #map #map */ Array.prototype.mapThis = function(block) { return this.collectThis.apply(this, arguments); }; /** + * An alias for #mapThis. + * + * @param {Function} block The function to execute. Should have one parameter + * @returns {Array} The array + * + * @see #mapThis #mapThis + * @see #map #map + */ +Array.prototype['map!'] = function(block) { + return this.mapThis.apply(this, arguments); +}; + +/** + * An alias for #hasMember. + * + * @param {Object} value A value to look for + * @returns {Boolean} <tt>true</tt> if value</t> is an element + * + * @see #hasMember #hasMember + * @see #include? #include? + */ +Array.prototype['member?'] = function(block) { + return this.hasMember.apply(this, arguments); +}; + +/** * Returns two arrays, the first containing the elements for which block * returns <tt>true</tt>, the second containing the rest. Invokes block * once for each element in the array, passing that element as an argument. @@ -771,6 +858,7 @@ Array.prototype.reject = function(block) { * @see #findAll #findAll * @see #grep #grep * @see #reject #reject + * @see #detect #detect */ Array.prototype.select = function(block) { var selected = []; src/lib/core.js @@ -160,6 +160,74 @@ Screw.Unit(function() { array_ = []; }); + describe('when sent #all? with a block', function() { + function doAllHUH() { + return doMethod('all?', {'on': array_, 'with': function(s) { }}); + } + + it('should not yield', function() { + expect(doAllHUH().callbacks[0]).to(be_empty); + }); + + it('should return true', function() { + expect(doAllHUH().returnValue).to(equal, true); + }); + + it('should not mutate itself', function() { + doAllHUH(); + expect(array_).to(equal, []); + }); + }); + + describe('when sent #all? without a block', function() { + function doAllHUHNoBlock() { + return doMethod('all?', {'on': array_}); + } + + it('should return true', function() { + expect(doAllHUHNoBlock().returnValue).to(equal, true); + }); + + it('should not mutate itself', function() { + doAllHUHNoBlock(); + expect(array_).to(equal, []); + }); + }); + + describe('when sent #any? with a block', function() { + function doAnyHUH() { + return doMethod('any?', {'on': array_, 'with': function(s) { }}); + } + + it('should not yield', function() { + expect(doAnyHUH().callbacks[0]).to(be_empty); + }); + + it('should return false', function() { + expect(doAnyHUH().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doAnyHUH(); + expect(array_).to(equal, []); + }); + }); + + describe('when sent #any? without a block', function() { + function doAnyHUHNoBlock() { + return doMethod('any?', {'on': array_}); + } + + it('should return false', function() { + expect(doAnyHUHNoBlock().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doAnyHUHNoBlock(); + expect(array_).to(equal, []); + }); + }); + describe('when sent #areAll with a block', function() { function doAreAll() { return doMethod('areAll', {'on': array_, 'with': function(s) { }}); @@ -268,6 +336,25 @@ Screw.Unit(function() { }); }); + describe('when sent #collect! with a block', function() { + function doCollectBANG() { + return doMethod('collect!', {'on': array_, 'with': function(s) { }}); + } + + it('should not yield', function() { + expect(doCollectBANG().callbacks[0]).to(be_empty); + }); + + it('should return itself', function() { + expect(doCollectBANG().returnValue).to(equal, array_); + }); + + it('should not mutate itself', function() { + doCollectBANG(); + expect(array_).to(equal, []); + }); + }); + describe('when sent #detect with a block', function() { function doDetect() { return doMethod('detect', {'on': array_, 'with': function(s) { }}); @@ -538,6 +625,21 @@ Screw.Unit(function() { }); }); + describe('when sent #include?', function() { + function doIncludeHUH() { + return doMethod('include?', {'on': array_, 'with': 'foo'}); + } + + it('should return false', function() { + expect(doIncludeHUH().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doIncludeHUH(); + expect(array_).to(equal, []); + }); + }); + describe('when sent #inject with a block', function() { function doInject() { return doMethod('inject', @@ -620,6 +722,40 @@ Screw.Unit(function() { }); }); + describe('when sent #map! with a block', function() { + function doMapBANG() { + return doMethod('map!', {'on': array_, 'with': function(s) { }}); + } + + it('should not yield', function() { + expect(doMapBANG().callbacks[0]).to(be_empty); + }); + + it('should return itself', function() { + expect(doMapBANG().returnValue).to(equal, array_); + }); + + it('should not mutate itself', function() { + doMapBANG(); + expect(array_).to(equal, []); + }); + }); + + describe('when sent #member?', function() { + function doMemberHUH() { + return doMethod('member?', {'on': array_, 'with': 'foo'}); + } + + it('should return false', function() { + expect(doMemberHUH().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doMemberHUH(); + expect(array_).to(equal, []); + }); + }); + describe('when sent #partition with a block', function() { function doPartition() { return doMethod('partition', {'on': array_, 'with': function(s) { }}); @@ -789,6 +925,168 @@ Screw.Unit(function() { array_ = ['foo', 'bar']; }); + describe('when sent #all? with a block that returns true', function() { + function doAllHUHTrue() { + return doMethod('all?', + {'on': array_, + 'with': function(s) { return true; }}); + } + + it('should yield twice', function() { + expect(doAllHUHTrue().callbacks[0].length).to(equal, 2); + }); + + it("should yield with itself as the 'this' value the first time", function() { + expect(doAllHUHTrue().callbacks[0][0].this).to(equal, array_); + }); + + it("should yield with itself as the 'this' value the second time", function() { + expect(doAllHUHTrue().callbacks[0][1].this).to(equal, array_); + }); + + it('should yield the first element the first time', function() { + expect(doAllHUHTrue().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should yield the second element the second time', function() { + expect(doAllHUHTrue().callbacks[0][1].arguments).to(equal, ['bar']); + }); + + it('should return true', function() { + expect(doAllHUHTrue().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAllHUHTrue(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #all? with a block that returns false', function() { + function doAllHUHFalse() { + return doMethod('all?', + {'on': array_, + 'with': function(s) { return false; }}); + } + + it('should yield once', function() { + expect(doAllHUHFalse().callbacks[0].length).to(equal, 1); + }); + + it("should yield with itself as the 'this' value", function() { + expect(doAllHUHFalse().callbacks[0][0].this).to(equal, array_); + }); + + it('should yield the first element', function() { + expect(doAllHUHFalse().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should return false', function() { + expect(doAllHUHFalse().returnValue).to(be_false); + }); + + it('should not mutate itself', function() { + doAllHUHFalse(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #all? without a block', function() { + function doAllHUHNoBlock() { + return doMethod('all?', {'on': array_}); + } + + it('should return true', function() { + expect(doAllHUHNoBlock().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAllHUHNoBlock(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #any? with a block that returns true', function() { + function doAnyHUHTrue() { + return doMethod('any?', + {'on': array_, + 'with': function(s) { return true; }}); + } + + it('should yield once', function() { + expect(doAnyHUHTrue().callbacks[0].length).to(equal, 1); + }); + + it("should yield with itself as the 'this' value", function() { + expect(doAnyHUHTrue().callbacks[0][0].this).to(equal, array_); + }); + + it('should yield the first element', function() { + expect(doAnyHUHTrue().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should return true', function() { + expect(doAnyHUHTrue().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAnyHUHTrue(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #any? with a block that returns false', function() { + function doAnyHUHFalse() { + return doMethod('any?', + {'on': array_, + 'with': function(s) { return false; }}); + } + + it('should yield twice', function() { + expect(doAnyHUHFalse().callbacks[0].length).to(equal, 2); + }); + + it("should yield with itself as the 'this' value the first time", function() { + expect(doAnyHUHFalse().callbacks[0][0].this).to(equal, array_); + }); + + it("should yield with itself as the 'this' value the second time", function() { + expect(doAnyHUHFalse().callbacks[0][1].this).to(equal, array_); + }); + + it('should yield the first element the first time', function() { + expect(doAnyHUHFalse().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should yield the second element the second time', function() { + expect(doAnyHUHFalse().callbacks[0][1].arguments).to(equal, ['bar']); + }); + + it('should return false', function() { + expect(doAnyHUHFalse().returnValue).to(be_false); + }); + + it('should not mutate itself', function() { + doAnyHUHFalse(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #any? without a block', function() { + function doAnyHUHNoBlock() { + return doMethod('any?', {'on': array_}); + } + + it('should return true', function() { + expect(doAnyHUHNoBlock().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAnyHUHNoBlock(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + describe('when sent #areAll with a block that returns true', function() { function doAreAllTrue() { return doMethod('areAll', @@ -1025,6 +1323,43 @@ Screw.Unit(function() { }); }); + describe('when sent #collect! with a block', function() { + function doCollectBANG() { + return doMethod('collect!', + {'on': array_, + 'with': function(s) { return 'item: ' + s; }}); + } + + it('should yield twice', function() { + expect(doCollectBANG().callbacks[0].length).to(equal, 2); + }); + + it("should yield with itself as the 'this' value the first time", function() { + expect(doCollectBANG().callbacks[0][0].this).to(equal, array_); + }); + + it("should yield with itself as the 'this' value the second time", function() { + expect(doCollectBANG().callbacks[0][1].this).to(equal, array_); + }); + + it('should yield the first element the first time', function() { + expect(doCollectBANG().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should yield the second element the second time', function() { + expect(doCollectBANG().callbacks[0][1].arguments).to(equal, ['bar']); + }); + + it('should return itself', function() { + expect(doCollectBANG().returnValue).to(equal, array_); + }); + + it('should mutate itself as expected', function() { + doCollectBANG(); + expect(array_).to(equal, ['item: foo', 'item: bar']); + }); + }); + describe('when sent #detect with a block that returns true', function() { function doDetectTrue() { return doMethod('detect', @@ -1803,6 +2138,36 @@ Screw.Unit(function() { }); }); + describe('when sent #include? with a member', function() { + function doIncludeHUHPassingMember() { + return doMethod('include?', {'on': array_, 'with': 'foo'}); + } + + it('should return true', function() { + expect(doIncludeHUHPassingMember().returnValue).to(equal, true); + }); + + it('should not mutate itself', function() { + doIncludeHUHPassingMember(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #include? with a non-member', function() { + function doIncludeHUHPassingNonmember() { + return doMethod('include?', {'on': array_, 'with': 'something else'}); + } + + it('should return false', function() { + expect(doIncludeHUHPassingNonmember().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doIncludeHUHPassingNonmember(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + describe('when sent #inject with a block', function() { function doInject() { return doMethod('inject', @@ -1951,6 +2316,73 @@ Screw.Unit(function() { }); }); + describe('when sent #map! with a block', function() { + function doMapBANG() { + return doMethod('map!', + {'on': array_, + 'with': function(s) { return 'item: ' + s; }}); + } + + it('should yield twice', function() { + expect(doMapBANG().callbacks[0].length).to(equal, 2); + }); + + it("should yield with itself as the 'this' value the first time", function() { + expect(doMapBANG().callbacks[0][0].this).to(equal, array_); + }); + + it("should yield with itself as the 'this' value the second time", function() { + expect(doMapBANG().callbacks[0][1].this).to(equal, array_); + }); + + it('should yield the first element the first time', function() { + expect(doMapBANG().callbacks[0][0].arguments).to(equal, ['foo']); + }); + + it('should yield the second element the second time', function() { + expect(doMapBANG().callbacks[0][1].arguments).to(equal, ['bar']); + }); + + it('should return itself', function() { + expect(doMapBANG().returnValue).to(equal, array_); + }); + + it('should mutate itself as expected', function() { + doMapBANG(); + expect(array_).to(equal, ['item: foo', 'item: bar']); + }); + }); + + describe('when sent #member? with a member', function() { + function doMemberHUHPassingMember() { + return doMethod('member?', {'on': array_, 'with': 'foo'}); + } + + it('should return true', function() { + expect(doMemberHUHPassingMember().returnValue).to(equal, true); + }); + + it('should not mutate itself', function() { + doMemberHUHPassingMember(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + + describe('when sent #member? with a non-member', function() { + function doMemberHUHPassingNonmember() { + return doMethod('member?', {'on': array_, 'with': 'something else'}); + } + + it('should return false', function() { + expect(doMemberHUHPassingNonmember().returnValue).to(equal, false); + }); + + it('should not mutate itself', function() { + doMemberHUHPassingNonmember(); + expect(array_).to(equal, ['foo', 'bar']); + }); + }); + describe('when sent #partition with a block that returns true', function() { function doPartitionTrue() { return doMethod('partition', @@ -2195,6 +2627,36 @@ Screw.Unit(function() { array_ = ['foo', null]; }); + describe('when sent #all? without a block', function() { + function doAllHUHNoBlock() { + return doMethod('all?', {'on': array_}); + } + + it('should return false', function() { + expect(doAllHUHNoBlock().returnValue).to(be_false); + }); + + it('should not mutate itself', function() { + doAllHUHNoBlock(); + expect(array_).to(equal, ['foo', null]); + }); + }); + + describe('when sent #any? without a block', function() { + function doAnyHUHNoBlock() { + return doMethod('any?', {'on': array_}); + } + + it('should return true', function() { + expect(doAnyHUHNoBlock().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAnyHUHNoBlock(); + expect(array_).to(equal, ['foo', null]); + }); + }); + describe('when sent #areAll without a block', function() { function doAreAllNoBlock() { return doMethod('areAll', {'on': array_}); @@ -2233,6 +2695,36 @@ Screw.Unit(function() { array_ = [true, false]; }); + describe('when sent #all? without a block', function() { + function doAllHUHNoBlock() { + return doMethod('all?', {'on': array_}); + } + + it('should return false', function() { + expect(doAllHUHNoBlock().returnValue).to(be_false); + }); + + it('should not mutate itself', function() { + doAllHUHNoBlock(); + expect(array_).to(equal, [true, false]); + }); + }); + + describe('when sent #any? without a block', function() { + function doAnyHUHNoBlock() { + return doMethod('any?', {'on': array_}); + } + + it('should return true', function() { + expect(doAnyHUHNoBlock().returnValue).to(be_true); + }); + + it('should not mutate itself', function() { + doAnyHUHNoBlock(); + expect(array_).to(equal, [true, false]); + }); + }); + describe('when sent #areAll without a block', function() { function doAreAllNoBlock() { return doMethod('areAll', {'on': array_}); src/spec/core-spec.js 39da5b851a177a491491992083ce2b5d46b62516 Nils Jonsson nils@alumni.rice.edu http://github.com/njonsson/rouge/commit/0d87150d468653832b07df216ca8be12774afad6 0d87150d468653832b07df216ca8be12774afad6

2009-06-06T20:42:27-07:00

Add Array#all?, Array#any?, Array#collect!, Array#include?, Array#map!, and Array#member? a8996d67d34f0a8aaf65da119ba89deffb173849 Nils Jonsson nils@alumni.rice.edu