Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

SecondAttempt #14

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

SecondAttempt #14

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 15 additions & 4 deletions koans/AboutApplyingWhatWeHaveLearnt.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
var _; //globals
var _; //globals ?????

describe("About Applying What We Have Learnt", function() {

Expand Down Expand Up @@ -32,16 +32,27 @@ describe("About Applying What We Have Learnt", function() {
}
}

expect(productsICanEat.length).toBe(FILL_ME_IN);
expect(productsICanEat.length).toBe(1);
});

it("given I'm allergic to nuts and hate mushrooms, it should find a pizza I can eat (functional)", function () {

var productsICanEat = [];
_(numbers).filter(function (x) { return x % 2 !== 0 })
var isEven = function(x) { return x % 2 === 0 };

/* solve using filter() & all() / any() */
expect(_(onlyEven).any(isEven)).toBe(true);


expect(productsICanEat.length).toBe(FILL_ME_IN);
/* solve using filter() & all() / any() */
var canEat = [];
var noNuts = _(products).filter( function (x) {
if ( x.containsNuts == "false") {
return x;
});
var noMushrooms =

expect(productsICanEat.length).toBe(1);
});

/*********************************************************************************/
Expand Down
64 changes: 32 additions & 32 deletions koans/AboutArrays.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,16 +3,16 @@ describe("About Arrays", function() {
//We shall contemplate truth by testing reality, via spec expectations.
it("should create arrays", function() {
var emptyArray = [];
expect(typeof(emptyArray)).toBe(FILL_ME_IN); //A mistake? - http:javascript.crockford.com/remedial.html
expect(emptyArray.length).toBe(FILL_ME_IN);
expect(typeof(emptyArray)).toBe(object Array); //A mistake? - http:javascript.crockford.com/remedial.html
expect(emptyArray.length).toBe(0);

var multiTypeArray = [0, 1, "two", function () { return 3; }, {value1: 4, value2: 5}, [6, 7]];
expect(multiTypeArray[0]).toBe(FILL_ME_IN);
expect(multiTypeArray[2]).toBe(FILL_ME_IN);
expect(multiTypeArray[3]()).toBe(FILL_ME_IN);
expect(multiTypeArray[4].value1).toBe(FILL_ME_IN);
expect(multiTypeArray[4]["value2"]).toBe(FILL_ME_IN);
expect(multiTypeArray[5][0]).toBe(FILL_ME_IN);
expect(multiTypeArray[0]).toBe(0);
expect(multiTypeArray[2]).toBe("two");
expect(multiTypeArray[3]()).toBe(3);
expect(multiTypeArray[4].value1).toBe(4);
expect(multiTypeArray[4]["value2"]).toBe(5);
expect(multiTypeArray[5][0]).toBe(6);
});

it("should understand array literals", function () {
Expand All @@ -23,36 +23,36 @@ describe("About Arrays", function() {
expect(array).toEqual([1]);

array[1] = 2;
expect(array).toEqual([1, FILL_ME_IN]);
expect(array).toEqual([1, 2]);

array.push(3);
expect(array).toEqual(FILL_ME_IN);
expect(array).toEqual([1,2,3]);
});

it("should understand array length", function () {
var fourNumberArray = [1, 2, 3, 4];

expect(fourNumberArray.length).toBe(FILL_ME_IN);
expect(fourNumberArray.length).toBe(4);
fourNumberArray.push(5, 6);
expect(fourNumberArray.length).toBe(FILL_ME_IN);
expect(fourNumberArray.length).toBe(6);

var tenEmptyElementArray = new Array(10);
expect(tenEmptyElementArray.length).toBe(FILL_ME_IN);
expect(tenEmptyElementArray.length).toBe(10);

tenEmptyElementArray.length = 5;
expect(tenEmptyElementArray.length).toBe(FILL_ME_IN);
expect(tenEmptyElementArray.length).toBe(5);
});

it("should slice arrays", function () {
var array = ["peanut", "butter", "and", "jelly"];

expect(array.slice(0, 1)).toEqual(FILL_ME_IN);
expect(array.slice(0, 2)).toEqual(FILL_ME_IN);
expect(array.slice(2, 2)).toEqual(FILL_ME_IN);
expect(array.slice(2, 20)).toEqual(FILL_ME_IN);
expect(array.slice(3, 0)).toEqual(FILL_ME_IN);
expect(array.slice(3, 100)).toEqual(FILL_ME_IN);
expect(array.slice(5, 1)).toEqual(FILL_ME_IN);
expect(array.slice(0, 1)).toEqual("peanut");
expect(array.slice(0, 2)).toEqual("peanut, butter");
expect(array.slice(2, 2)).toEqual();
expect(array.slice(2, 20)).toEqual(["and", "jelly"]);
expect(array.slice(3, 0)).toEqual();
expect(array.slice(3, 100)).toEqual("jelly");
expect(array.slice(5, 1)).toEqual();
});

it("should know array references", function () {
Expand All @@ -62,36 +62,36 @@ describe("About Arrays", function() {
refArray[1] = "changed in function";
}
passedByReference(array);
expect(array[1]).toBe(FILL_ME_IN);
expect(array[1]).toBe("changed in function");

var assignedArray = array;
assignedArray[5] = "changed in assignedArray";
expect(array[5]).toBe(FILL_ME_IN);
expect(array[5]).toBe("changed in assignedArray"); //??

var copyOfArray = array.slice();
copyOfArray[3] = "changed in copyOfArray";
expect(array[3]).toBe(FILL_ME_IN);
expect(array[3]).toBe("three");
});

it("should push and pop", function () {
var array = [1, 2];
array.push(3);
array.push(3); // stack

expect(array).toEqual(FILL_ME_IN);
expect(array).toEqual([1, 2, 3]);

var poppedValue = array.pop();
expect(poppedValue).toBe(FILL_ME_IN);
expect(array).toEqual(FILL_ME_IN);
expect(poppedValue).toBe(3);
expect(array).toEqual([1, 2]);
});

it("should know about shifting arrays", function () {
var array = [1, 2];

array.unshift(3);
expect(array).toEqual(FILL_ME_IN);
array.unshift(3);
expect(array).toEqual([3, 1, 2]);

var shiftedValue = array.shift();
expect(shiftedValue).toEqual(FILL_ME_IN);
expect(array).toEqual(FILL_ME_IN);
expect(shiftedValue).toEqual(3);
expect(array).toEqual([1, 2]);
});
});
14 changes: 7 additions & 7 deletions koans/AboutExpects.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,37 +2,37 @@ describe("About Expects", function() {

//We shall contemplate truth by testing reality, via spec expectations.
it("should expect true", function() {
expect(false).toBeTruthy(); //This should be true
expect(true).toBeTruthy(); //This should be true
});

//To understand reality, we must compare our expectations against reality.
it("should expect equality", function () {
var expectedValue = FILL_ME_IN;
var expectedValue = 2;
var actualValue = 1 + 1;

expect(actualValue === expectedValue).toBeTruthy();
});

//Some ways of asserting equality are better than others.
it("should assert equality a better way", function () {
var expectedValue = FILL_ME_IN;
var expectedValue = 2;
var actualValue = 1 + 1;

// toEqual() compares using common sense equality.
expect(actualValue).toEqual(expectedValue);
});

//Sometimes you need to be really exact about what you "type".
it("should assert equality with ===", function () {
var expectedValue = FILL_ME_IN;
var expectedValue = '2';
var actualValue = (1 + 1).toString();

// toBe() will always use === to compare.
expect(actualValue).toBe(expectedValue);
});

//Sometimes we will ask you to fill in the values.
it("should have filled in values", function () {
expect(1 + 1).toEqual(FILL_ME_IN);
expect(1 + 1).toEqual(2);
});
});
33 changes: 18 additions & 15 deletions koans/AboutFunctions.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ describe("About Functions", function() {
return a + b;
}

expect(add(1, 2)).toBe(FILL_ME_IN);
expect(add(1, 2)).toBe(3);
});

it("should know internal variables override outer variables", function () {
Expand All @@ -21,9 +21,9 @@ describe("About Functions", function() {
return message;
}

expect(getMessage()).toBe(FILL_ME_IN);
expect(overrideMessage()).toBe(FILL_ME_IN);
expect(message).toBe(FILL_ME_IN);
expect(getMessage()).toBe("Outer");
expect(overrideMessage()).toBe("Inner");
expect(message).toBe("Outer");
});

it("should have lexical scoping", function () {
Expand All @@ -35,21 +35,21 @@ describe("About Functions", function() {
}
return childfunction();
}
expect(parentfunction()).toBe(FILL_ME_IN);
expect(parentfunction()).toBe("local");
});

it("should use lexical scoping to synthesise functions", function () {

function makeIncreaseByFunction(increaseByAmount) {
return function (numberToIncrease) {
return function (numberToIncrease) { // ??
return numberToIncrease + increaseByAmount;
};
}

var increaseBy3 = makeIncreaseByFunction(3);
var increaseBy5 = makeIncreaseByFunction(5);

expect(increaseBy3(10) + increaseBy5(10)).toBe(FILL_ME_IN);
expect(increaseBy3(10) + increaseBy5(10)).toBe(28); // ?? Confused by Syntax.
});

it("should allow extra function arguments", function () {
Expand All @@ -58,23 +58,23 @@ describe("About Functions", function() {
return firstArg;
}

expect(returnFirstArg("first", "second", "third")).toBe(FILL_ME_IN);
expect(returnFirstArg("first", "second", "third")).toBe("first");

function returnSecondArg(firstArg, secondArg) {
return secondArg;
}

expect(returnSecondArg("only give first arg")).toBe(FILL_ME_IN);
expect(returnSecondArg("only give first arg")).toBe();

function returnAllArgs() {
var argsArray = [];
for (var i = 0; i < arguments.length; i += 1) {
argsArray.push(arguments[i]);
argsArray.push(arguments[i]); // Does this mean that arguments is innately known?
}
return argsArray.join(",");
}

expect(returnAllArgs("first", "second", "third")).toBe(FILL_ME_IN);
expect(returnAllArgs("first", "second", "third")).toBe("first,second,third");
});

it("should pass functions as values", function () {
Expand All @@ -88,21 +88,24 @@ describe("About Functions", function() {
};

var praiseSinger = { givePraise: appendRules };
expect(praiseSinger.givePraise("John")).toBe(FILL_ME_IN);
expect(praiseSinger.givePraise("John")).toBe("John rules!");

praiseSinger.givePraise = appendDoubleRules;
expect(praiseSinger.givePraise("Mary")).toBe(FILL_ME_IN);
expect(praiseSinger.givePraise("Mary")).toBe("Mary totally rules!");

});

it("should use function body as a string", function () {
var add = new Function("a", "b", "return a + b;");
expect(add(1, 2)).toBe(FILL_ME_IN);
expect(add(1, 2)).toBe(3);

var multiply = function (a, b) {
//An internal comment
return a * b;
};
expect(multiply.toString()).toBe(FILL_ME_IN);
expect(multiply.toString()).toBe("function (a, b) {
//An internal comment
return a * b;
}");
});
});
36 changes: 18 additions & 18 deletions koans/AboutHigherOrderFunctions.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,17 +11,17 @@ describe("About Higher Order Functions", function () {
var numbers = [1,2,3];
var odd = _(numbers).filter(function (x) { return x % 2 !== 0 });

expect(odd).toEqual(FILL_ME_IN);
expect(odd.length).toBe(FILL_ME_IN);
expect(numbers.length).toBe(FILL_ME_IN);
expect(odd).toEqual({1,3});
expect(odd.length).toBe(2);
expect(numbers.length).toBe(3);
});

it("should use 'map' to transform each element", function () {
var numbers = [1, 2, 3];
var numbersPlus1 = _(numbers).map(function(x) { return x + 1 });

expect(numbersPlus1).toEqual(FILL_ME_IN);
expect(numbers).toEqual(FILL_ME_IN);
expect(numbersPlus1).toEqual([2, 3, 4]);
expect(numbers).toEqual([1, 2, 3]);
});

it("should use 'reduce' to update the same result on each iteration", function () {
Expand All @@ -34,8 +34,8 @@ describe("About Higher Order Functions", function () {
/* initial */ 0
);

expect(reduction).toBe(FILL_ME_IN);
expect(numbers).toEqual(FILL_ME_IN);
expect(reduction).toBe(6); // ??
expect(numbers).toEqual([1, 2, 3]);
});

it("should use 'forEach' for simple iteration", function () {
Expand All @@ -47,8 +47,8 @@ describe("About Higher Order Functions", function () {

_(numbers).forEach(isEven);

expect(msg).toEqual(FILL_ME_IN);
expect(numbers).toEqual(FILL_ME_IN);
expect(msg).toEqual("falsetruefalse");
expect(numbers).toEqual([1,2,3]);
});

it("should use 'all' to test whether all items pass condition", function () {
Expand All @@ -57,8 +57,8 @@ describe("About Higher Order Functions", function () {

var isEven = function(x) { return x % 2 === 0 };

expect(_(onlyEven).all(isEven)).toBe(FILL_ME_IN);
expect(_(mixedBag).all(isEven)).toBe(FILL_ME_IN);
expect(_(onlyEven).all(isEven)).toBe(true);
expect(_(mixedBag).all(isEven)).toBe(false);
});

it("should use 'any' to test if any items passes condition" , function () {
Expand All @@ -67,18 +67,18 @@ describe("About Higher Order Functions", function () {

var isEven = function(x) { return x % 2 === 0 };

expect(_(onlyEven).any(isEven)).toBe(FILL_ME_IN);
expect(_(mixedBag).any(isEven)).toBe(FILL_ME_IN);
expect(_(onlyEven).any(isEven)).toBe(true);
expect(_(mixedBag).any(isEven)).toBe(true);
});

it("should use range to generate an array", function() {
expect(_.range(3)).toEqual(FILL_ME_IN);
expect(_.range(1, 4)).toEqual(FILL_ME_IN);
expect(_.range(0, -4, -1)).toEqual(FILL_ME_IN);
expect(_.range(3)).toEqual([0, 1, 2]);
expect(_.range(1, 4)).toEqual([1, 2, 3]);
expect(_.range(0, -4, -1)).toEqual([0, -1, -2, -3]);
});

it("should use flatten to make nested arrays easy to work with", function() {
expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual(FILL_ME_IN);
expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual([1, 2, 3, 4]);
});

it("should use chain() ... .value() to use multiple higher order functions", function() {
Expand All @@ -88,7 +88,7 @@ describe("About Higher Order Functions", function () {
.reduce(function (sum, x) { return sum + x })
.value();

expect(result).toEqual(FILL_ME_IN);
expect(result).toEqual(6);
});

});
Expand Down
Loading